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 Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io;
use std::io::*;
use std::str::FromStr;
 
 
fn abc(s: String, k: i64) {
    for s_ in s.chars() {
        println!("{}", s_);
        break;
    }
    /*
    let one: String = '1'.to_string();
    let two: String = "2".to_string().repeat(4_999_999_999_999_999_usize.pow(2u32));
    let three: String = "3".to_string().repeat(4_999_999_999_999_999_usize.pow(3u32));
    let four: String = "4".to_string().repeat(4_999_999_999_999_999_usize.pow(4u32));
    let five: String = "5".to_string().repeat(4_999_999_999_999_999_usize.pow(5u32));
    let six: String = "6".to_string().repeat(4_999_999_999_999_999_usize.pow(6u32));
    let seven: String = "7".to_string().repeat(4_999_999_999_999_999_usize.pow(7u32));
    let eight: String = "8".to_string().repeat(4_999_999_999_999_999_usize.pow(8u32));
    let nine: String = "9".to_string().repeat(4_999_999_999_999_999_usize.pow(9u32));

    let temp = "";
    println!("{:?}", one);
    
    for s_ in s.chars() {
        if s_ == '1'{
            [temp, one.to_string()].concat();
        } else if s_ == '2' {
            [temp, two].concat();
        } else if s_ == '3' {
            [temp, three].concat();
        } else if s_ == '4' {
            [temp, four].concat();
        } else if s_ == '5' {
            [temp, five].concat();
        } else if s_ == '6' {
            [temp, six].concat();
        } else if s_ == '7' {
            [temp, seven].concat();
        } else if s_ == '8' {
            [temp, eight].concat();
        } else if s_ == '9' {
            [temp, nine].concat();
        }
        if temp.chars().count() >= k {
            break;
        }
    }
    let tmp = temp.chars().collect();
    
    return tmp[k]
    */
}
 

 
fn main() {
    let s: String = read();
    let k: i64 = read();

    let result = abc(s, k);
    
    //println!("{}", result);
}

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