Even though the provided string is infinite, the string has a very particular structure. Let's analyze the example, specifically $\text{COWWCO}$ to $\text{COWWCOOCOWWC}$. In particular, note that the index 7 maps to index 6, but indices 8 through 12 map to indices 1 through 5.

For notational convenience, let $F^k(s) = F(F^{k-1}(s))$, and define $F^0(s) = s$.

We can compute the smallest $k$ such that $F^k(s)$ contains the given index. If $k=0$, then we are looking at the original string and can therefore return the character directly. Otherwise, take $F^k(s)$ and split it into two halves. The desired index must be in the second half of $F^k(s)$. If it is the first character in the second half, then we want to return the last character in $F^{k-1}(s)$. Otherwise, due to the rotation, we decrease the index by 1 and return that character in $F^{k-1}(s)$.

Applying that approach directly gives us an $O(\log^2 N)$ algorithm, which is fast enough for our purposes. It can also be improved to $O(\log N)$.

import java.io.*;
import java.util.*;
public class cowcode {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("cowcode.in"));
		PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("cowcode.out")));
		StringTokenizer st = new StringTokenizer(br.readLine());
		String s = st.nextToken();
		long index = Long.parseLong(st.nextToken());
		pw.println(parse(s, index-1));
		pw.close();
	}

	public static char parse(String s, long index) {
		if(index < s.length()) {
			return s.charAt((int)index);
		}
		long length = s.length();
		while(2*length <= index) {
			length *= 2;
		}
		if(length == index) {
			return parse(s, length-1);
		}
		return parse(s, index - length - 1);
	}
}