```go
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024*1024*10), 1024*1024*10)
	scanner.Split(bufio.ScanWords)

	if !scanner.Scan() {
		return
	}
	sBytes := scanner.Bytes()
	n := int32(len(sBytes))

	S := make([]byte, n)
	copy(S, sBytes)

	if !scanner.Scan() {
		return
	}
	m, _ := strconv.Atoi(scanner.Text())

	f := make([]int32, n+1)
	path := make([]int32, n+1)
	pos_in_path := make([]int32, n+1)
	cycle_idx := make([]int32, n+1)
	pos_in_cycle := make([]int32, n+1)
	visited := make([]bool, n+1)
	cycle_nodes := make([]int32, n+1)
	cycle_offset := make([]int32, n+1)
	cycle_length := make([]int32, n+1)
	P := make([]int32, n)
	newS := make([]byte, n)

	writer := bufio.NewWriterSize(os.Stdout, 1024*1024)
	defer writer.Flush()

	for q := 0; q < m; q++ {
		if !scanner.Scan() {
			break
		}
		k_int, _ := strconv.Atoi(scanner.Text())
		if !scanner.Scan() {
			break
		}
		d_int, _ := strconv.Atoi(scanner.Text())

		k := int32(k_int)
		d := int32(d_int)

		if d == 1 || d >= k {
			writer.Write(S)
			writer.WriteByte('\n')
			continue
		}

		new_idx := int32(0)
		for r := int32(0); r < d; r++ {
			for x := r; x < k; x += d {
				f[x] = new_idx
				new_idx++
			}
		}

		path_len := int32(0)
		curr := k - 1
		for curr != 0 {
			path[path_len] = curr
			path_len++
			curr = f[curr] - 1
		}
		path[path_len] = 0
		path_len++

		for i := int32(0); i < k; i++ {
			pos_in_path[i] = -1
			visited[i] = false
		}
		for i := int32(0); i < path_len; i++ {
			node := path[i]
			pos_in_path[node] = i
			visited[node] = true
		}

		cycle_ptr := int32(0)
		num_cycles := int32(0)
		for i := int32(1); i < k; i++ {
			if !visited[i] {
				start_ptr := cycle_ptr
				c := i
				for !visited[c] {
					visited[c] = true
					cycle_idx[c] = num_cycles
					pos_in_cycle[c] = cycle_ptr - start_ptr
					cycle_nodes[cycle_ptr] = c
					cycle_ptr++
					c = f[c] - 1
				}
				cycle_offset[num_cycles] = start_ptr
				cycle_length[num_cycles] = cycle_ptr - start_ptr
				num_cycles++
			}
		}

		for j := int32(0); j < n; j++ {
			var t_in, x_in, T int32
			if j < k {
				t_in = 0
				x_in = j
				T = n - k + 1
			} else {
				t_in = j - k + 1
				x_in = k - 1
				T = n - j
			}

			if pos_in_path[x_in] != -1 {
				d_x := path_len - 1 - pos_in_path[x_in]
				if d_x <= T-1 {
					P[j] = t_in + d_x
				} else {
					p := path[pos_in_path[x_in]+T]
					P[j] = n - k + 1 + p
				}
			} else {
				c_id := cycle_idx[x_in]
				p_c := pos_in_cycle[x_in]
				length := cycle_length[c_id]
				new_p := (p_c + T) % length
				p := cycle_nodes[cycle_offset[c_id]+new_p]
				P[j] = n - k + 1 + p
			}
		}

		for j := int32(0); j < n; j++ {
			newS[P[j]] = S[j]
		}
		for j := int32(0); j < n; j++ {
			S[j] = newS[j]
		}

		writer.Write(S)
		writer.WriteByte('\n')
	}
}
```