jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;

public class Main {

	char[] S;

	public void solve() {
		S = next().toCharArray();

		int[] a = new int[26];
		for(char c : S){
			a[c-'a']++;
		}

		for(int i : a){
			if(i > 1){
				out.println("no");
				return;
			}
		}
		out.println("yes");
	}

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

	/* Input */
	private static final InputStream in = System.in;
	private static final PrintWriter out = new PrintWriter(System.out);
	private final byte[] buffer = new byte[2048];
	private int p = 0;
	private int buflen = 0;

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

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

	private boolean isPrint(int ch) {
		if (ch >= '!' && ch <= '~')
			return true;
		return false;
	}

	private int nextByte() {
		if (!hasNextByte())
			return -1;
		return buffer[p++];
	}

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

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

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

	public double nextDouble() {
		return Double.parseDouble(next());
	}
}
//  [java]
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main{
	static final Scanner s=new Scanner(System.in);
	static int getInt(){
		return Integer.parseInt(s.next());
	}
	static IntStream REPS(int l) {
		return IntStream.range(0,l);
	}
	public static void main(String[]__){
		int[]m=new int[26];
		for(char c:s.next().toCharArray())
			m[c-'a']++;
		System.out.println(
				Arrays.stream(m).anyMatch(i->i>1)
				?"no":"yes"
				);
	}
}
//  [java]
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String S = sc.next();

        System.out.println(solve(S) ? "yes" : "no");

        sc.close();
    }

    static boolean solve(String S) {
        return S.chars().distinct().count() == S.length();
    }
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Queue;

public class Main implements Runnable{

	public static void main(String[] args) {
		new Thread(null,new Main(), "" ,Runtime.getRuntime().maxMemory()).start();
	}
	
	int gcd(int a,int b) {
		return a==0?b:gcd(b%a,a);
	}
	
	public void run() {
		FastScanner sc=new FastScanner();
		int[] cnt=new int[26];
		char[] cs=sc.next().toCharArray();
		for(char c:cs)cnt[(int)(c-'a')]++;
		System.out.println(Arrays.stream(cnt).filter(v->v>1).sum()==0?"yes":"no");
	}
	
	void tr(Object...objects) {System.out.println(Arrays.deepToString(objects));}
}

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());}
}
//  [cpp]
#include<stdio.h>
#include<string.h>
int num[200];
int main(){
	char a[50];
	while(scanf("%s",a)!=EOF){
		memset(num,0,sizeof(num));
		int s=strlen(a),i,g;
		for(i=0;i<s;i++){
			g=a[i]-'a';
			num[g]++;
		}
		int flag=0;
		for(i=0;i<=26;i++){
			if(num[i]>1){
				flag=1;
				break;
			}
		}
		if(flag==0)
			printf("yes\n");
		else
			printf("no\n");
	}
	return 0;
}
//  [cpp]
#include <stdio.h>

void po(char s[])
{
	for(int i=0;s[i]!='\0';i++)
	{
		for(int j=0;j<i;j++)
		{
			if(s[i]==s[j])
			{
				printf("no\n");
				return;
			}
		}
	}
	printf("yes\n");
}

int main(void)
{
	char s[26];
	scanf("%s",s);
	po(s);
	return 0;
}
//  [cpp]
#include <stdio.h>
#include <string.h>

int main()
{
	char s[30];
	int a[26]={0};
	scanf("%s",s);
	int n=strlen(s);
	for(int i=0;i<n;i++)
		a[s[i]-'a']++;
	int dif=0;
	for(int i=0;i<26;i++)
		if(a[i]>1){
			dif=1;	break;
		}	
	if(dif==0)
		printf("yes");
	else
		printf("no");
	return 0; 
}
//  [cpp]
#include "bits/stdc++.h"

#define ALL(a) (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define DESCSORT(c) sort(c.begin(), c.end(), greater<int>())

using namespace std;

using LL = long long int;
using LD = long double;

using pii = pair<int, int>;
using pll = pair<LL, LL>;
using pdd = pair<double, double>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vl = vector<LL>;
using vvl = vector<vl>;
using vvvl = vector<vvl>;
using vd = vector<double>;
using vvd = vector<vd>;
using vs = vector<string>;
using vb = vector<bool>;
using vvb = vector<vb>;

const int INF = (1 << 30) - 1;
const LL INF64 = ((LL)1 << 62) - 1;
const double PI = 3.1415926535897932384626433832795;

const int dy[] = { 0, 1, 0, -1 };
const int dx[] = { 1, 0, -1, 0 };

int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
LL gcd(LL x, LL y) { return y ? gcd(y, x % y) : x; }


int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);

	string s;
	cin >> s;

	vi vec(26);
	for (int i = 0; i < s.size(); i++) {
		vec[s[i] - 'a']++;
	}

	for (int i = 0; i < vec.size(); i++) {
		if (vec[i] >= 2) {
			cout << "no" << endl;
			return 0;
		}
	}

	cout << "yes" << endl;
	return 0;
}
//  [cpp]
/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author Kishan Sairam Adapa
 */

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define ll long long int
#define MOD ((int)(1e9) + 7)

using namespace std;

class BVaried {
public:
    void solve(istream& cin, ostream& cout) {
        string s;
        cin >> s;
        vector<int> cnt(26, 0);

        for(auto k : s) cnt[k - 'a']++;
        for(auto k: cnt) {
            if(k > 1) {
                cout << "no\n";
                return;
            }
        }
        cout << "yes\n";
    }
};


int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);
    BVaried solver;
    std::istream& in(std::cin);
    std::ostream& out(std::cout);
    solver.solve(in, out);
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repn(i,n) for(int i = 0; i <= (int)(n); i++)
#define srep(i,l,n) for(int i = l; i < (int)(n); i++)
#define srepn(i,l,n) for(int i = l; i <= (int)(n); i++)
#define drep(i,n) for(int i = (int)(n-1); i >= 0; i--)
#define drepn(i,n) for(int i = (int)(n); i >= 0; i--)
#define size(s) (int)s.size()
#define debug(var)  do{std::cout << #var << " : ";view(var);}while(0)
template<typename T> void view(T e){std::cout << e << std::endl;}
template<typename T> void view(const std::vector<T>& v){for(const auto& e : v){ std::cout << e << " "; } std::cout << std::endl;}
template<typename T> void view(const std::vector<std::vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
template<typename T> inline istream& operator>>(istream &i, vector<T> &v) {rep(j, size(v)) i >> v[j]; return i;}
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<class T> T gcd(T a, T b) {if(b==0)return a; else return gcd(b,a%b);}
template<class T> T lcm(T a, T b) {return a/gcd(a,b)*b;}
template<class T = int> using V = vector<T>;
template<class T = int> using VV = vector<V<T>>;
bool isIn(int i, int j, int h, int w) {return i >= 0 && i < h && j >= 0 && j < w;}
void Yes(){cout << "Yes" << endl;}
void No(){cout << "No" << endl;}
void YES(){cout << "YES" << endl;}
void NO(){cout << "NO" << endl;}
void err() {cout << -1 << endl;}
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pb push_back
#define ep emplace_back

const int MOD = 1000000007;
const int INF = 1e9;

#define PI acos(-1);
int dx[4] = {1,-1,0,0};
int dy[4] = {0,0,1,-1};
int ddx[8] = {1,1,1,-1,-1,-1,0,0};
int ddy[8] = {0,1,-1,0,1,-1,1,-1};


int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    string s;
    cin >> s;
    map<char, int> mp;
    bool ok = true;
    for(auto c : s) {
        mp[c]++;
        if(mp[c] > 1) ok = false; 
    }
    if(ok) cout << "yes" << endl;
    else cout << "no" << endl;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>

int main(void)
{
	char S[100];
	scanf("%s\n",S);
	int tbl[26];
	memset(tbl,0,sizeof(tbl));
	char *p = S;
	while (*p){
		int index = (*p)-'a';
		if (tbl[index]>0){
			printf("no\n");
			return 0;
		}
		tbl[index]++;
		p++;
	}
	printf("yes\n");
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>

int main(void)
{
	int len, i,j, ans = 0;
	char s[28], ch;
	scanf("%s", s);
	len = strlen(s);
	for(i = 0; i < len; i++){
		ch = s[i];
		for(j = i+1; j < len; j++){
			if(ch == s[j])
				ans++;
		}
		if(ans > 0)
			break;
	}
	if(ans > 0)
		printf("no");
	else
		printf("yes");
	return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>

int main() {
	char s[27];
	int len;
	int flag[26];
	int loop;
	scanf("%s", s);
	len = strlen(s);
	for (loop = 0; loop < 26; loop++)flag[loop] = 1;
	for (loop = 0; loop < len; loop++) 
		if (flag[s[loop] - 'a']-- == 0) {
			printf("no\n");
			return 0;
		
	}
	printf("yes\n");
	return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>

int main(void){
    char a[50];
    int i,j,k=0;

    gets(a);

    for(i=0;i<strlen(a);i++){
        for(j=i+1;j<strlen(a);j++){
            if(a[i]==a[j]){
                k++;
            }
        }
    }

    if(k==0){
        printf("yes");
    }
    else{
        printf("no");
    }

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

int main(void)
{
    char string[27];

    scanf("%s", string);
    for(int i=0;string[i] != '\0'; i++)
    {
        for (int j = i +1; string[j] != '\0'; j++)
        {
            if(string[i] == string[j])
            {
                    printf("no\n");
                    return (0);
            }
        }
    }
    printf("yes\n");
}
//  [c]
#include <stdio.h>
#include <unistd.h>

int	main(void)
{
  int	i = 0;
  int	j;
  char	str[27] = {0};
  
  read(0, str, 26);
  while (str[i])
  {
    j = i + 1;
    while (str[j])
    {
      if (str[i] == str[j])
      {
        printf("no");
        return (0);
      }
      j++;
    }
    i++;
  }
  printf("yes");
  return (0);
}
//  [javascript]
function Main(input) {
	input = input.trim();
  var list = "abcdefghijklmnopqrstuvwxyz".split("");
  for(var i = 0; i < input.length; i++){
    var tmp = input.slice(i , i + 1);
    if(list.indexOf(tmp) != -1){
       list.splice(list.indexOf(tmp), 1);
       }else{
         console.log("no");
         return;
       }
  }
  console.log("yes");
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'
function Main(input) {
  // inputの文字列をとってきたもの
  let text = input.trim().split("");
  // ユニークになるように再セットしたもの
  let textSet = new Set(text);
  // 回答用の変数
  let ans = "";
  // 全てがユニークなら等しくなるので
  ans = +text.length == +textSet.size ? "yes" : "no";
  
  console.log(ans);
}

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

const main = (input) => {
    const S = input.split('\n')[0]
    const length = S.length
    const arrLength = [...new Set(S.split(''))].length
    if(length === arrLength){
        console.log('yes')
    }else{
        console.log('no')
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf-8'))
//  [javascript]
'use strict'

function main(input) {
  input = input.split('')
  const n = input.length
  const ss = input.filter((v, i, self) => {
    return self.indexOf(v) == i
  })

  if (ss.length == n) {
    console.log('yes')
  } else {
    console.log('no')
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function Main(input) {
    
	//var r;
	
	input = input.split("\n");
	
	//var line = input[0].split(" ");
	
	var line = input[0]
	
	var temp = {}
	
	for(var i=0; i<line.length; i++) {
	    if(line[i] in temp) {
	        console.log("no")
	        return;
	    }
	    temp[line[i]] = 1
	}
	
	
    
	console.log("yes");
    
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main( input ){
	input = input.split( '\n' )
  var str = input[0]

  var book = {}
  var flg = true
  for( var i=0; i<str.length; i++ ){
    if( book[str[i]] === undefined ) book[str[i]] = true
    else {
      flg = false
      break
    }
  }

  console.log( flg ? 'yes' : 'no' )
}

Main( require( 'fs' ).readFileSync( '/dev/stdin', 'utf8' ) )
//  [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)))
}

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)
	//X: 最初のマス
	S = nextStr()

	m := make(map[string]int, len(S))
	ans := "yes"
	for i := 0; i < len(S); i++ {
		s := string(S[i])
		//mapにkeyが存在するか判定
		if _, ok := m[s]; ok {
			ans = "no"
			break
		} else {
			m[s] = 1
		}
	}

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

import (
        "fmt"
)

func solution(s string) string {
        var a [26]int
        for _, r := range s {
                if a[r-'a'] != 0 {
                        return "no"
                }
                a[r-'a']++
        }
        return "yes"
}

func main() {
        var s string
        fmt.Scan(&s)
        fmt.Println(solution(s))
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var s string
	fmt.Scanf("%s", &s)

	f := true
	set := make(map[rune]bool)
	for _, c := range(s) {
		if set[c] {
			fmt.Println("no")
			f = false
			break
		}
		set[c] = true
	}
	if f {
		fmt.Println("yes")
	}
}
//  [go]
package main

import (
	"fmt"
	"unicode/utf8"
	// "sort"
	//"regexp"
)

var s string

func main() {
	fmt.Scan(&s)
	length := utf8.RuneCountInString(s)
	m := map[string]int{}
	for i := 0; i < length; i++ {
		m[s[i:i+1]] = m[s[i:i+1]] + 1
	}
	for _, v := range m {
		if v > 1 {
			fmt.Print("no")
			return
		}
	}
	fmt.Println("yes")
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	scanInit()

	s := nextStr()

	m := map[int]int{}

	for i := 0; i < len(s); i++ {
		tmp := s[i]
		m[int(tmp)]++
		if m[int(tmp)] >= 2 {
			fmt.Println("no")
			return
		}
	}
	fmt.Println("yes")
}

// ---- 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"
)

func main() {
	var wtr = bufio.NewWriter(os.Stdout)

	var S string
	fmt.Scan(&S)
	m := map[int32]bool{}
	var ans bool
	for _, v := range S {
		if _, ok := m[v]; ok {
			ans = true
			break
		}
		m[v] = true

	}
	if ans {
		fmt.Fprintln(wtr, "no")
	} else {
		fmt.Fprintln(wtr, "yes")
	}

	_ = wtr.Flush()
}
//  [ruby]
S = gets.chomp
T = S.split('').uniq
puts S.length == T.length ? "yes" : "no"
//  [ruby]
s = gets.chomp
puts s.size == s.chars.uniq.size ? :yes: :no
//  [ruby]
s = gets.strip.split("")
puts s.count == s.uniq.count ? "yes" : "no"
//  [ruby]
require 'prime'
require 'set'
require 'tsort'
include Math
def max(a,b);              a > b ? a : b                              end
def min(a,b);              a < b ?  a : b                             end
def swap(a,b);             a, b = b, a                                end
def gif;                   gets.to_i                                  end
def gff;                   gets.to_f                                  end
def gsf;                   gets.chomp                                 end
def gi;                    gets.split.map(&:to_i)                     end
def gf;                    gets.split.map(&:to_f)                     end
def gs;                    gets.chomp.split.map(&:to_s)               end
def gc;                    gets.chomp.split('')                       end
def pr(num);               num.prime_division                         end
def digit(num);            num.to_s.length                            end
def array(s,ini=nil);      Array.new(s){ini}                          end
def darray(s1,s2,ini=nil); Array.new(s1){Array.new(s2){ini}}          end
def rep(num);              num.times{|i|yield(i)}                     end
def repl(st,en,n=1);       st.step(en,n){|i|yield(i)}                 end

s = gc
list = []
ans = true
s.each do |ss|
if list.include? ss
  ans = false
  break
end
list << ss
end

puts ans ? "yes" : "no"
//  [ruby]
S=gets
puts S.size == S.split(//).uniq.size ? "yes" : "no"
//  [ruby]
require "set"
s1= gets.chop.split("")
s2 = Set.new(s1)
if s1.size == s2.size
    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")
}

use std::collections::HashMap;

fn main() {
    let s: String = read();
    let mut map: HashMap<char, bool> = HashMap::new();
    let sc: Vec<char> = s.chars().collect();
    for i in sc {
        if map.contains_key(&i) {
            println!("no");
            return
        } else {
            map.insert(i, true);
        }
    }
    println!("yes");
}
//  [rust]
use std::io;
use std::collections::HashSet;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let s:Vec<char> = buf.trim().chars().collect();
	let mut set = HashSet::new();
	let mut flag = true;
	for i in s {
		if !set.insert(i) {
			flag = false;
			println!("no");
			break;
		}
	}
	if flag {
		println!("yes");
	}
}
//  [rust]
use itertools::Itertools;

fn main() {
    proconio::input! {
    a:String,
  }
    let e=['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 mut v=[0;26];
    let a=a.chars().collect_vec();
    for i in 0..a.len() {
        for j in 0..26 {
            if a[i]==e[j] {
                if v[j]==1{println!("no");std::process::exit(0)}
                v[j]=1;
            }
        }
    }
    println!("yes")
}
//  [rust]
#[allow(unused_imports)]
use std::{cmp::Reverse, collections::*};

#[allow(unused_imports)]
use proconio::{
    fastout, input,
    marker::{Chars, Usize1},
};

#[allow(unused_imports)]
use itertools::Itertools;

#[allow(unused_imports)]
use num::Integer;

#[fastout]
pub fn main() {
    input! {
        s: Chars,
    }
    println!(
        "{}",
        if s.len() == s.iter().unique().count() {
            "yes"
        } else {
            "no"
        }
    );
}
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;

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

#[fastout]
fn main() {
    input!{
        s: Chars,
    }
    let mut alpha: Vec<usize> = vec![0;26];
    for i in 0..s.len() {
        alpha[s[i] as usize - 'a' as usize] += 1;
    }
    for i in 0..alpha.len() {
        if alpha[i] > 1 {
            println!("no");
            return;
        }
    }
    println!("yes");
}
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

var S = readLine()!.toArray()
var output = "yes"
for _ in 0..<S.count {
    let c = S.last!
    S.removeLast()
    if S.contains(c) {
        output = "no"
        break
    }
}
print(output)
//  [swift]
import Foundation

let s = readLine()!
print(Set(s).count == s.count ? "yes" : "no")
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);const tn=():number=>{const a=input[0];input.shift();return Number(a)};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{const a=input[0];input.shift();return String(a)};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const tc=():string=>{let a=input[0].split('');const b=a[0];a.shift();if(a.length>0){input[0]=a.join('')}else{input.shift()}return String(b)};const tcc=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(tc())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1];}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const objvs =(a)=>{const b=[];for(const v in a){b.push(a[v])}return b};const deduplicate=(a):any[]=>{return Array.from(new Set(a))};
const main=()=>{
  let s=ts().split('')
  let a=s.length;
  s=deduplicate(s)
  to(a==s.length?'yes':'no')
}
main()
//  [typescript]
import { readFileSync } from "fs";

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

const main = (input: string[][]) => {
  const S = input[0][0];

  return new Set(S.split("")).size === S.length ? "yes" : "no";
};

console.log(main(read()));
//  [python]
L,R = list(map(int, input().split()))

MOD=[0] * (2019*2019)

def myidx(i,j):
    return i * 2019 + j

for i in range(2019):
    for j in range(i+1,2019):
        idx = myidx(i,j)
        MOD[idx] = (i*j) % 2019

#for i in range(2019):
#    idx = myidx(i,i)
#    MOD[idx] = 2019

MMM = []
MIN = 2019
Lmod = L % 2019
Rmod = R % 2019

if L+2019 <= R:
    for i in range(2019):
        for j in range(i+1,2019):
            idx = myidx(i,j)
            MIN = min(MIN, MOD[idx])
            #MMM.append(MOD[idx])
elif Lmod <= Rmod:
    for i in range(Lmod, Rmod+1):
        for j in range(i+1, Rmod+1):
            idx = myidx(i,j)
            MIN = min(MIN, MOD[idx])
            #MMM.append(MOD[idx])

elif Lmod > Rmod:
    for i in list(range(0,Rmod+1)) + list(range(Lmod, 2019)):
        for j in list(range(i+1,Rmod+1)) + list(range(max(Lmod,i+1), 2019)):
            idx = myidx(i,j)
            MIN = min(MIN, MOD[idx])
            #MMM.append(MOD[idx])

#MMM=list(set(MMM))
#MMM.sort()
#print(MMM.pop(0))
print(MIN)
//  [python]
l,r = map(int,input().split())

r = min(r, l+4038)

min = 99999999
for i in range(l,r):
  for j in range(i+1,r+1):
    value = (i*j)%2019
    if min > value:
      min = value
print(min)
//  [python]
def f_c():
    l, r = map(int, input().split())

    c = 2019
    for i in range(l, r+1):
        for j in range(l, r+1):
            if i%2019 == 0 or j%2019==0:
                print(0)
                return 0
            elif i == j:
                pass
            else:
                c = min(i*j%2019, c)
    print(c)

if __name__ == "__main__":
    f_c()
//  [java]
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        long L = scan.nextLong();
        long R = scan.nextLong();
        
        long result = 2018;

        for (long i = L; i < R; i++){
            for (long j = i + 1; j <= R; j++){
                long mod = (i * j) % 2019;
                if(result == 0) break;
                if(result > mod) result = mod;
                if(result == 0) break;
            }
        }

        System.out.println(result);
    }
}
//  [java]
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		long l = sc.nextInt();
		long r = sc.nextInt();
		long min = 2018;
		for (long i = l; i < r; i++) {

			for (long j = i + 1; j <= r; j++) {
				if (min == 0)
					break;
				if (i * j % 2019 < min)
					min = i * j % 2019;
				if (min == 0)
					break;
			}
		}

		System.out.println(min);
	}
}
//  [java]
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets;

public class Main {

	public static void main(String[] args) throws IOException {
		InputStreamReader reader = new InputStreamReader(System.in, StandardCharsets.UTF_8);
		BufferedReader in = new BufferedReader(reader);
		String[] tokens = in.readLine().split(" ");
		long L = Long.parseLong(tokens[0]);
		long R = Long.parseLong(tokens[1]);
		long result = 0;
		if (R - L >= 2018) {
			result = 0;
		} else {
			List<Long> mods = new ArrayList<>();
			for (long i = L; i < R; ++i) {
				for (long j = i + 1; j <= R; ++j) {
					mods.add((i % 2019) * (j % 2019) % 2019);
				}
			}
			Collections.sort(mods);
			result = mods.get(0);
		}
		System.out.println(result);
		in.close();
	}

}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
 
int main(){
 
    long long int l,r;
    cin >> l >> r;
    long long int ans = 2019;
 
    for(long long int i = l; i < r; ++i){
        for(long long int j = i+1; j<= r && j < l+2019; ++j){
            ans = min((i*j)%2019, ans);
            // if(ans == 0)break;
        }
    }
 
    cout << ans << endl;
 
 
}
//  [cpp]
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
#include <map>
#include <numeric>
#include <set>
#include <iomanip>
#include <functional>
#define FOR(i, a, n) for (int i = (a); i < (n); i++)
#define REP(i, n) for(int i = 0; i < (n); i++)
using namespace std;

int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	int L, R, mod_min = 1000000;
	int c = 0;

	cin >> L >> R;

	for (int i = L; i < R; i++)
	{
		for (int j = i + 1; j < R + 1; j++)
		{
			if (c >= 2039190)break;

			if (((i % 2019)*(j % 2019)) % 2019 < mod_min)
			{
				mod_min = ((i % 2019)*(j % 2019)) % 2019;
			}
			c++;
		}
	}

	cout << mod_min << endl;

	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main(){

    long long int l,r;
    cin >> l >> r;
    long long int ans = 2019;

    for(long long int i = l; i < r; ++i){
        for(long long int j = i+1; j<= r && j < l + 2019; ++j){
            ans = min((i*j)%2019, ans);
            if(ans == 0)break;
        }
    }

    cout << ans << endl;


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

#define LENGTH 2000000000

int main(void)
{
    int L, R, i, j, ij_2019;
    scanf("%d %d", &L, &R);
    if (0 > L || 0 > R || L >= R || L > LENGTH || R > LENGTH)
    {
        exit(0);
    }
    else
    {
        if ((R - L) >= 2019)
        {
            printf("0");
        }
        else
        {
            i = L;
            j = R;
            L %= 2019;
            R %= 2019;
            if (L >= R)
            {
                R += 2019;
            }
            int ij_2019_min = 50000;
            for (int i = L; i <= (j - 1); i++)
            {
                for (int j = i + 1; j <= R; j++)
                {
                    ij_2019 = (i * j) % 2019;
                    if (ij_2019 < ij_2019_min)
                    {
                        ij_2019_min = ij_2019;
                    }
                    if(ij_2019_min == 0){
                        printf("0");
                        return 0;
                    }
                }
            }
            printf("%d", ij_2019_min);
        }
    }
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <math.h>
int main(void){
    
    int l;
    int r;
    int minus;
    int minusx;
    int id;
    int jd;
    int ans = 2018;
    int tmp;
    int loop;
    
    scanf("%d%d", &l, &r);
    
    minus = r - l;
    minusx = minus / 20190;
    minus = minusx * 20190;
    r -= minus;
    
    for(int i=l; i<r; i++){
        
        loop = 0;
        
        for(int j=i+1; j<=r; j++){
            
            id = i % 2019;
            jd = j % 2019;
            
            tmp = id * jd;
            tmp %= 2019;
            
            if(tmp<ans){
                
                ans = tmp;
                
            }
            
            
        }
        
    }
    
    printf("%d", ans);
    
    return 0;
    
}
//  [c]
#include<stdio.h>
int minc(long a,long b){
if(a>b)return b;
  else return a;
}
int main(void){
  long l,r;
  scanf("%ld%ld",&l,&r);
 int  min=2020;
 r=minc(r,l+4038);
  for(long i=l;i<=r;i++){
    for(long j=l;j<=r;j++){
      if(j==i)continue;
      if(i*j%2019<min)min=i*j%2019;
    }
  }
  printf("%d",min);
  return 0;
}
//  [javascript]
"use strict";
    
const main = arg => {
  
  let L = arg.split(" ")[0],
      R = arg.split(" ")[1],
      Lmod = arg.split(" ")[0] % 2019,
      Rmod = arg.split(" ")[1] % 2019;

  let min = 2018;
  if(R - L + 1 >= 2019) {
        console.log(0);
  } else {
    for(let i = Lmod; i <= Rmod; i++){
      for(let j = Lmod; j <= Rmod; j++){
        let num = (i*j) % 2019;
        if( (num < min) && (i < j) ){
          min = num;
        }
      }
    }

    console.log(min);
  }
}

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

const main = input => {
	const args = input.trim().split(' ')
	const L = parseInt(args[0], 10)
	const R = parseInt(args[1], 10)
	
	if (R - L >= 2018) {
		console.log(0)
	} else {
		let min = 2018
		const L2 = L % 2019
		const R2 = R % 2019

		for (let i = L2; i < R2; i++) {
			for (let j = i + 1; j <= R2; j++) {
				min = Math.min(min, (i * j) % 2019)
			}
		}

		console.log(min)
	}
}

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

import (
	"fmt"
	"sort"
)

func main() {

	var L,R int

	fmt.Scan(&L,&R)
  
  	if R-L >= 2019{

		fmt.Println(0)

		return
	}

	var res[]int 

	for i:=L;i<=R;i++{

		for j:=i+1;j<=R;j++{

			res = append(res, (i*j)%2019)
		}
	}

	sort.Sort(sort.IntSlice(res))

	fmt.Println(res[0])

}


//SliceInt 引数サイズのSliceを返す
func SliceInt(a int) []int {

	IntSample := make([]int, a)

	return IntSample

}
//  [go]
package main

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

const pi = math.Pi

var 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 int
var mod int = pow(10, 9) + 7
var Umod uint64 = 2019
var ans int = 1e9

func main() {
	var L, R int
	fmt.Scan(&L, &R)

	// i*j = k...p (mod 2019)
	// (i*j+p) = k*2019
	if 2019 <= R-L {
		fmt.Println(0)
	} else {
		for i := L; i <= R-1; i++ {
			for j := L + 1; j <= R; j++ {
				cnt := i * j % 2019
				ans = min(ans, cnt)
			}
		}
		fmt.Println(ans)
	}
}

/*  ----------------------------------------  */

var reader = bufio.NewScanner(os.Stdin)

func read() string {
	reader.Scan()
	return reader.Text()
}

func lcm(x, y int) int {
	return (x / gcd(x, y)) * y
}

func gcd(x, y int) int {
	if x%y == 0 {
		return y
	} else {
		r := x % y
		return gcd(y, r)
	}
}

var fac [1000000]int
var finv [1000000]int
var inv [1000000]int

func combination_init() {
	fac[0], fac[1] = 1, 1
	finv[0], finv[1] = 1, 1
	inv[1] = 1

	// invは a^(-1) mod p
	// pをaで割ることを考える

	// p/a*(a) + p%a = p
	// p/a*(a) + p%a = 0          (mod p)
	// -p%a = p/a*(a)             (mod p)
	// -p%a *a^(-1)= p/a          (mod p)
	// a^(-1)= p/a * (-p%a)^(-1)  (mod p)
	// a^(-1) =

	for i := 2; i < 1000000; i++ {
		fac[i] = fac[i-1] * i % mod
		inv[i] = mod - inv[mod%i]*(mod/i)%mod
		finv[i] = finv[i-1] * inv[i] % mod
	}
}

func combination(x, y int) int {
	if x < y {
		return 0
	}
	if fac[0] != 1 {
		combination_init()
	}
	return fac[x] * (finv[y] * finv[x-y] % mod) % mod
	//return fac[x] / (fac[y] * fac[x-y])
}

func permutation(x, y int) int {
	if x < y {
		return 0
	}
	if fac[0] != 1 {
		combination_init()
	}
	return fac[x] * (finv[x-y] % mod) % mod
	//return fac[x] / fac[x-y]
}

func max(x ...int) int {
	var res int = x[0]
	for i := 1; i < len(x); i++ {
		res = int(math.Max(float64(x[i]), float64(res)))
	}
	return res
}

func min(x ...int) int {
	var res int = x[0]
	for i := 1; i < len(x); i++ {
		res = int(math.Min(float64(x[i]), float64(res)))
	}
	return res
}
func pow(x, y int) int { return int(math.Pow(float64(x), float64(y))) }
func abs(x int) int    { return int(math.Abs(float64(x))) }
func floor(x int) int  { return int(math.Floor(float64(x))) }
func ceil(x int) int   { return int(math.Ceil(float64(x))) }

type SortBy []int

func (a SortBy) Len() int           { return len(a) }
func (a SortBy) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a SortBy) Less(i, j int) bool { return a[i] > a[j] }

type PriorityQueue []int

func (h PriorityQueue) Len() int            { return len(h) }
func (h PriorityQueue) Less(i, j int) bool  { return h[i] < h[j] }
func (h PriorityQueue) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *PriorityQueue) Push(x interface{}) { *h = append(*h, x.(int)) }
func (h *PriorityQueue) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}
//  [ruby]
L, R = gets.split.map(&:to_i)

target = []
tmp = L
for i in 1..2019
    break if tmp > R 
    target.push(tmp)
    tmp += 1
end

ans = 2020
target.each_with_index{|x,xi|
    target.each_with_index{|y,yi|
        next if xi == yi
        # puts ("x=#{x} xi=#{xi} y=#{y} yi=#{yi}")
        ans = [(x*y)%2019, ans].min
    }
}

puts ans
//  [ruby]
L,R=gets.split.map(&:to_i)
p L.upto([R,L+10000000].min).map{|i|i%2019}.uniq.combination(2).map{|a,b|(a*b)%2019}.min
//  [ruby]
l, r = gets.chop.split.map(&:to_i)

ans = 2018


l_end = [l+2019, r].min

for i in l..l_end-1 do
  for j in (l+1)..l_end do

      ans = [ans ,i * j % 2019].min
  end
end

p ans
//  [rust]
#[allow(unused_macros)]
macro_rules! input {
    ( $($t:ty),* ) => {{
        let mut s = String::new();
        std::io::stdin().read_line(&mut s);
        let mut splits = s.trim().split_whitespace();
        ($( { splits.next().unwrap().parse::<$t>().unwrap() },)*)
    }}
}

#[allow(unused_must_use)]
#[allow(unused_variables)]
fn solve() {
    let (l, r) = input!(usize, usize);
    let mut count = 0;
    let mut set = std::collections::HashSet::with_capacity(2019);

    for i in l..(r+1) {
        let mut inner_count = 0;
        for j in (i+1)..(r+1) {
            set.insert((i * j) % 2019);
            if inner_count == 2019 {
                break;
            }
            inner_count += 1;
        }
        if count == 2019 {
            break;
        }
        count += 1;
    }

    println!("{}", set.iter().min().unwrap());
}

fn main() {
    solve();
}
//  [rust]
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;
#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;
#[allow(unused_imports)]
use std::f64::consts::*;

#[allow(unused)]
const INF: usize = std::usize::MAX / 4;
#[allow(unused)]
const M: usize = 1000000007;

fn main() {
    input! {
        l: usize,
        r: usize,
    }
    let mut div = vec![];
    for x in l..=min(r, l + 2019 * 2) {
        div.push(x % 2019);
    }
    let mut result = INF;
    for j in 0..div.len() {
        for i in 0..j {
            result = min(result, div[i] * div[j] % 2019);
        }
    }
    println!("{}", result);
}
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))};
const main=()=>{
  let [l,r]=tnn(2),n=2019
  if(r-l>=2019){
    to(0)
    return
  }
  l=l%n
  r=r%n
  if(r<=l){
    to(0)
    return
  }
  let m=n
  for(let i=l;i<=r;i++){
    for(let j=i+1;j<=r;j++){
      m=min(m,i*j%n)
      if(m==0)break
    }
    if(m==0)break
  }
  to(m)
}
main()
//  [python]
import sys
import numpy as np

readInt = lambda: int(sys.stdin.readline())
readIntN = lambda: [int(v) for v in sys.stdin.readline().split(' ')]

n = readInt()
s = sys.stdin.readline().strip()

w = 0
b = 0
for c in s:
    w += int(c == '.')
    b += int(c == '#')


wc = 0
bc = 0
ret = min(w, b)
for c in s:
    wc += int(c == '.')
    bc += int(c == '#')

    ret = min(ret, bc + (w - wc))
print(ret)
//  [python]
# encoding:utf-8
import copy
import numpy as np
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import math

N = int(input())
S = str(input())

ans = 10**6
blacks = [0 for i in range(N)]
black = 0
white = 0
for i in range(N):
    if S[i] == "#":
        black += 1

    else:
        white += 1
    blacks[i] = black

ans = min(black,white,ans)

# print(blacks)
for i in range(1,N):
    cnt = 0
    cnt += (N-(i+1))-(blacks[N-1]-blacks[i])#white
    # print("white",cnt)
    cnt += blacks[i-1]#black
    # print(cnt)
    ans = min(ans,cnt)

print(ans)
//  [python]
N=int(input())
S=input()
cur=0
lis=["" for i in range(N)]
lis[cur]=S[0]
for c in S[1:]:
	ss=lis[cur]
	if c==".":
		lis[cur]=ss+"."
	else:
		if ss[-1]=="#":
			lis[cur]=ss+"#"
		else:
			cur+=1
			lis[cur]="#"
def counting(sss):
	curb=sss.find("#")
	curw=sss.rfind(".")
	return tuple([sss[:curw+1].count("#"),sss[curb:].count(".")])

c=0
lasc=0
kugi=[]
for l in lis:
	if l=="":
		break
	else:
		ka=counting(l)
		c+=ka[0]
		kugi.append(ka)
lasc=c
for w,b in kugi[::-1]:
	c=c-w+b
	if c<lasc:
		lasc=c
print(lasc)
//  [java]
import java.util.*;

public class Main {

    public static void main(String args[]) {

        // 入力
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.next());
        String s = sc.next();
        sc.close();

        // 主処理
        int result = solve(n, s);

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

    private static int solve(int n, String s) {
        if (!s.contains(".") || !s.contains("#")) {
            return 0;
        }
        int black = s.replaceAll("[^#]", "").length();
        int white = s.replaceAll("[^.]", "").length();
        int countReplace = Math.min(black, white);

        int[] countBlack = new int[n];
        int[] countWhite = new int[n];
        char[] c = s.toCharArray();
        int cb = 0;
        int cw = 0;
        for (int i = 0; i < n; i++) {
            if (c[i] == '#') {
                cb++;
            }
            countBlack[i] = cb;
            if (c[n - 1 - i] == '.') {
                cw++;
            }
            countWhite[n - 1 - i] = cw;
        }
        int count = n;
        for (int i = 0; i < n - 1; i++) {
            count = Math.min(count, countBlack[i] + countWhite[i + 1]);
        }

        return Math.min(countReplace, count);
    }
}
//  [java]
import java.util.Arrays;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
		
		Scanner keyboard = new Scanner(System.in); 
		
		int N = keyboard.nextInt();
		String S = keyboard.next();
		
		String[] ishi1 = S.split("");
		int count = 0;
		
		int[] Lkuro = new int[N];
		int[] Rshiro = new int[N];
		
		for (int i = 1; i < S.length(); i++) {
			if(ishi1[i-1].equals("#")) {
				Lkuro[i] = Lkuro[i-1] + 1;	
			}else {
				Lkuro[i] = Lkuro[i-1];
			}
		}
		
		for (int j = S.length() - 2; j >= 0; j--) {
			if(ishi1[j+1].equals(".")) {
				Rshiro[j] = Rshiro[j+1] + 1;	
			}else {
				Rshiro[j] = Rshiro[j+1];
			}
		}
		
		int kotae = 1000000;
		
		for(int k = 0; k < S.length(); k++) {
			kotae = Math.min(kotae, Lkuro[k]+ Rshiro[k]);
		}
		
		System.out.println(kotae);
		keyboard.close();
	}
}
//  [java]
import java.io.*;
import java.util.*;

public class Main{
  public static void main(String[] args)throws IOException{
    //BufferedReader br = new BufferedReader(System.in);
    Scanner sc = new Scanner(System.in);
    PrintWriter out = new PrintWriter(System.out);
    
    int num = sc.nextInt();
		String[] line = sc.next().split("");
    int cnt = 0;
		int min = num;
		
		for(int i=0; i<num; i++)
		  if(line[i].equals("."))
		  	cnt++;
		
		int sum = cnt;
		for(int i=0; i<num; i++){
		  if(sum < min)
		  	min = sum;
		  if(line[i].equals("#"))
		  	sum++;
		  else sum--;
		}
		
		if(sum < min)
			min = sum;
		
		out.println(min);
    
    out.flush();
  }
}
//  [cpp]
#include <iostream>
#include <vector>
using namespace std;

int main() {
  int n;
  string s;
  cin >> n >> s;
  int cntb = 0;
  int cntw = 0;
  vector<pair<int, int>> v;
  for (int i = 0; i < n; i++) {
    if (s[i] == '#') {
      if (i != 0 && s[i - 1] == '.') {
        v.push_back({cntb, cntw});
        cntb = 1;
        cntw = 0;
      } else {
        cntb++;
      }
    } else {
      cntw++;
    }
  }
  v.push_back({cntb, cntw});
  int m = v.size();
  int ans = 1e9;
  for (int k = 0; k <= m; k++) {
    int tmp = 0;
    for (int i = 0; i < k; i++) {
      tmp += v[i].first;
    }
    for (int i = k; i < m; i++) {
      tmp += v[i].second;
    }
    ans = min(ans, tmp);
  }
  cout << ans << endl;
  return 0;
}