Problem:
﻿Score: 300 points

Problem Statement

Mr. Infinity has a string S consisting of digits from 1 to 9. Each time the date changes, this string changes as follows:

Each occurrence of 2 in S is replaced with 22. Similarly, each 3 becomes 333, 4 becomes 4444, 5 becomes 55555, 6 becomes 666666, 7 becomes 7777777, 8 becomes 88888888 and 9 becomes 999999999. 1 remains as 1.

For example, if S is 1324, it becomes 1333224444 the next day, and it becomes 133333333322224444444444444444 the day after next.
You are interested in what the string looks like after 5 \times 10^{15} days. What is the K-th character from the left in the string after 5 \times 10^{15} days?

Constraints

S is a string of length between 1 and 100 (inclusive).

K is an integer between 1 and 10^{18} (inclusive).

The length of the string after 5 \times 10^{15} days is at least K.

Input

Input is given from Standard Input in the following format:

S
K

Output

Print the K-th character from the left in Mr. Infinity's string after 5 \times 10^{15} days.

Sample Input 1

1214
4

Sample Output 1

2

The string S changes as follows:

Now: 1214

After one day: 12214444

After two days: 1222214444444444444444

After three days: 12222222214444444444444444444444444444444444444444444444444444444444444444

The first five characters in the string after 5 \times 10^{15} days is 12222. As K=4, we should print the fourth character, 2.

Sample Input 2

3
157

Sample Output 2

3

The initial string is 3. The string after 5 \times 10^{15} days consists only of 3.

Sample Input 3

299792458
9460730472580800

Sample Output 3

2

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.*;
import java.math.BigInteger;
import java.util.*;


public class Main {

    class A {
        BigInteger start;
        int value;
        BigInteger end;

        public BigInteger getStart() {
            return start;
        }

        public void setStart(BigInteger start) {
            this.start = start;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public BigInteger getEnd() {
            return end;
        }

        public void setEnd(BigInteger end) {
            this.end = end;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            A a = (A) o;
            return value == a.value &&
                    Objects.equals(start, a.start) &&
                    Objects.equals(end, a.end);
        }

        @Override
        public int hashCode() {
            return Objects.hash(start, value, end);
        }

        @Override
        public String toString() {
            return "A{" +
                    "start=" + start +
                    ", value=" + value +
                    ", end=" + end +
                    '}';
        }
    }

    private void solve(InputReader in, PrintWriter out) {
        String s = in.next();
        long k = in.nextLong();
        BigInteger res = BigInteger.ONE;
        List<A> list = new ArrayList<>();
        String[] arr = s.split("");
        for (int i = 0; i < arr.length; i++) {
            if (Integer.parseInt(arr[i]) == 1) {
                A a = new A();
                a.setStart(res);
                res = res.add(BigInteger.ONE);
                a.setValue(1);
                a.setEnd(res);
                list.add(a);
            } else {
                A a = new A();
                a.setStart(res);
                res = res.add(BigInteger.valueOf(Integer.parseInt(arr[i]) * 2 * 5000000000000000L));
                a.setValue(Integer.parseInt(arr[i]));
                a.setEnd(res);
                list.add(a);
            }
        }
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getStart().compareTo(BigInteger.valueOf(k)) <= 0 && list.get(i).getEnd().compareTo(BigInteger.valueOf(k)) > 0) {
                out.println(list.get(i).getValue());
                return;
            }
        }
    }


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

    private void run() {
        try (
                InputReader in = new InputReader(System.in);
                PrintWriter out = new PrintWriter(System.out)) {
            solve(in, out);
        }
    }


    static class InputReader implements AutoCloseable {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }


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

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

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

        @Override
        public void close() {

        }
    }


}