Language: C++

#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;

// < "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\b.txt"
using ll = long long int;
using ha = pair<ll, ll>;
struct RollingHash {
	static const ll mul0 = 10005349, mul1 = 10007;
	static const ll add0 = 1000010007, add1 = 1003333331;
	size_t len;
	//vector<ll> hash_, hash2_;
	vector<ha>hash_;
	//static vector<ll> pmo_, pmo2_;
	static vector<ha>pmo_;
	void init(const vector<ll>& s) {
		len = s.size();
		hash_.resize(len + 1);
		hash_[0] = make_pair(0, 0);

		if (pmo_.empty()) {
			pmo_.push_back(make_pair(1, 1));
		}
		while (pmo_.size() <= len) {
			pmo_.push_back(make_pair(pmo_.back().first*mul0, pmo_.back().second*mul1));
		}
		for (unsigned int i = 0; i < len; ++i) {
			hash_[i + 1] = make_pair((hash_[i].first * mul0 + s[i]), (hash_[i].second*mul1 + s[i]));
		}
		return;
	}
	void init(const string& s) {
		vector<ll>v;
		for (char c : s) {
			v.push_back(c);
		}
		init(v);
	}
	ha hash(const int l, const int r)const { // s[l..r]
		return make_pair(hash_[r + 1].first - hash_[l].first * pmo_[r + 1 - l].first,
			hash_[r + 1].second - hash_[l].second * pmo_[r + 1 - l].second);
	}
	ha  hash()const { // s[all]
		return hash(0, len - 1);
	}

	//hash????????????
	static ha concat(const ha L, const ha R, const int RLength) { // hash(L+R) 
		return make_pair((R.first + L.first*pmo_[RLength].first), (R.second + L.second*pmo_[RLength].second));
	}

	//index????????????from??????to????????????????????????????????\????????????
	ha get_changed_hash(const int index, const ll from, const ll to)const {
		const ha p(hash());
		return make_pair(
			p.first + (to - from) * pmo_[len - index - 1].first,
			p.second + (to - from) * pmo_[len - index - 1].second);
	}
	//index????????????from??????to????????????????????????????????\????????????
	ha get_changed_hash(const int index, const ll from, const ll to, const int l, const int r)const {
		const ha p(hash(l,r));
		if (l > index || r < index)return p;
		return make_pair(
			p.first + (to - from) * pmo_[r+1 - index - 1].first,
			p.second + (to - from) * pmo_[r+1 - index - 1].second);
	}
	void change_st(const int index, const ll from, const ll to)const {
	}
};
vector<ha> RollingHash::pmo_;

RollingHash rh;
int check(const pair<int, int>a, const pair<int, int>b) {
	int al = a.first, ar = a.second;
	int bl = b.first, br = b.second;
	int lans = -1;
	int rans = ar-al;
	while (lans + 1 != rans) {
		int midans = (lans + rans) / 2;
		if (rh.hash(al, al + midans) == rh.hash(bl, bl + midans)) {
			lans = midans;
		}
		else {
			rans = midans;
		}
	}
	if (rh.hash(al + rans+1, ar) == rh.hash(bl + rans+1, br))return rans;
	else return -1;
}
string st;
int changeind = -1;
char changeto = 0;
ha getha(const int l, const int r) {
	if (changeind != -1) {
		return rh.get_changed_hash(changeind,st[changeind],changeto,l, r);
	}
	else {
		ha h = rh.hash(l, r);
		return h;
	}
}
int L, R, T;
pair<bool,int> issame(int al, int bl,int len) {
	if (bl > R) {
		return make_pair(true, -1);
	}
	else {
		assert(bl <= R);
		int checklen = min(len, R - bl);
		bool same=  getha(a.first,a.first+ checklen) == getha(b.first,b.first+ checklen);
		if (same)return make_pair(1, -1);
		else {

			int acheck = check(make_pair(al,al+checklen), (make_pair(bl,bl+checklen)));
			return make_pair(false,acheck);
		}
	}
}
int main() { 
	cin >> st;
	rh.init(st);
	int N; cin >> N;
	while (N--) {
		changeind = -1;
		changeto = -1; cin >> L >> R >> T;
		L--; R--;
		int asize = R - L + 1;
		int nt = T;
		while (asize*2 >= nt) {
			nt *= 2;
		}
		bool ok = true;
		while (nt != T) {
			nt /= 2;
			if (nt >= asize)continue;
			auto ap = issame(L, L + nt, nt);
			if (ap.first)continue;
			else {
				int p(ap.second);
				if (p == -1) {
					ok = false;
					break;
				}
				else {
					if (changeind != -1) {
						ok = false;
						break;
					}else if (nt == T) {
						ok = true;
						break;
					}
					else {
						bool lsame = getha(L, L  + nt / 2 - 1) == getha(L  + nt / 2, L +nt-1);
						bool rsame;
						bool rflag = false;
						{
							const int l3 = L + nt;
							int r3 = L + nt + nt / 2 - 1;
							const int l4 = L + nt + nt / 2;
							int r4 = L + nt + nt - 1;
							if (l4 > R) {
								rsame = true;
								rflag = true;
							}
							else {
								if (r4 > R) {
									r4 = R;
									assert(l4 <= R);
									r3 = l3 + (r4 - l4);
								}
								rsame = getha(l3, r3) == getha(l4, r4);
								if (r3 < L + nt + p&&L + nt + p < l4)rflag = true;
							}
							
						}
						if (rflag) {
							if (lsame) {
								changeind = L + nt + p;
								changeto = st[L + p];
							}
							else {
								changeind = L + p;
								changeto = st[L + nt + p];
							}
						}
						else {
							if (lsame&&rsame)assert(false);
							else if (lsame&&!rsame) {
								changeind = L + nt + p;
								changeto = st[L + p];
							}
							else if (!lsame&&rsame) {
								changeind = L + p;
								changeto = st[L + nt + p];
							}
							else {
								ok = false;
								break;
							}
						}
						
					}
					
				}
				
			}
		}
		if (ok)cout << "Yes" << endl;
		else cout << "No" << endl;
	}
	return 0;
}

Compiler output:
a.cc: In function 'std::pair<bool, int> issame(int, int, int)':
a.cc:114:35: error: 'a' was not declared in this scope; did you mean 'al'?
  114 |                 bool same=  getha(a.first,a.first+ checklen) == getha(b.first,b.first+ checklen);
      |                                   ^
      |                                   al
a.cc:114:71: error: 'b' was not declared in this scope; did you mean 'bl'?
  114 |                 bool same=  getha(a.first,a.first+ checklen) == getha(b.first,b.first+ checklen);
      |                                                                       ^
      |                                                                       bl