Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {

	sc := bufio.NewScanner(os.Stdin)
	sc.Scan()
	args := strings.Split(sc.Text(), " ")
	n, _ := strconv.Atoi(args[0])
	t, _ := strconv.ParseInt(args[1], 10, 64)

	q, _ := strconv.Atoi(args[2])

	pos := make([]int64, n)
	direction := make([]bool, n)

	for i := 0; i < n; i++ {
		sc.Scan()
		args = strings.Split(sc.Text(), " ")

		pos[i], _ = strconv.ParseInt(args[0], 10, 64)
		q, _ := strconv.Atoi(args[1])
		if q == 1 {
			direction[i] = true
		}
	}

	qq := make([]int, q)
	for i := 0; i < q; i++ {
		sc.Scan()
		args = strings.Split(sc.Text(), " ")

		qq[i], _ = strconv.Atoi(args[0])
	}

	ans(n, q, t, pos, direction, qq)

}

func ans(n, q int, t int64, pos []int64, dir []bool, qq []int) {

	colleation := []int64{} // syoutotu positon

	for i := 1; i < n; i++ {
		if dir[i-1] == dir[i] {
			continue
		}
		colleation = append(colleation, (pos[i-1]+pos[i])/2)

	}
	//fmt.Println(colleation)
	for i := 0; i < q; i++ {
		var ans int64
		ans = int64(-9999999)
		if dir[qq[i]-1] == true {
			// 東向きなら現ポジから＋方向で一番近い衝突点との距離を求めて、Tとの差が
			for _, v := range colleation {
				if v <= pos[qq[i]-1] {
					continue
				} else {
					// 衝突予定点が確定。衝突点との距離がT以下なら衝突点で停止
					if v-pos[qq[i]-1] <= t {
						ans = v
					} else {
						ans = pos[qq[i]-1] + int64(t)
					}
					break
				}
			}
			if ans == -9999999 {
				ans = pos[qq[i]-1] + int64((t))
			}

		} else {
			// nishi向きなら現ポジから-方向で一番近い衝突点との距離を求めて、Tとの差が
			for j := len(colleation); j > 0; j-- {
				if colleation[j-1] >= pos[qq[i]-1] {
					continue
				}
				v := colleation[j-1]
				//fmt.Printf("hoge=%d\n", v)
				// 衝突予定点が確定
				if pos[qq[i]-1]-v <= t {
					ans = v
				} else {
					ans = pos[qq[i]-1] - int64((t))
				}
				break

			}
			if ans == -9999999 {
				ans = pos[qq[i]-1] - int64((t))
			}

		}
		fmt.Printf("%d\n", ans)

	}

}

C++: #include <bits/stdc++.h>
#define range(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, a) range(i, 0, a)
using namespace std;

int main() {
    long long n, t, q;
    cin >> n >> t >> q;
    vector <vector <long long>> ad(4);
    vector <long long> a(n), d(n);
    rep (i, n) {
        cin >> a[i] >> d[i], d[i]--;
        ad[d[i]    ].push_back( a[i]);
        ad[d[i] + 2].push_back(-a[i]);
    }
    sort(ad[2].begin(), ad[2].end());
    sort(ad[3].begin(), ad[3].end());
    // 0 := 右向き
    // 1 := 左向き
    // 2 := 右向き符号反転
    // 3 := 左向き符号反転

    rep (i, q) {
        int in;
        cin >> in, in--;
        auto itrA = d[in] == 0 ? lower_bound(ad[1].begin(),  ad[1].end(),  a[in])
                               : lower_bound(ad[2].begin(),  ad[2].end(), -a[in]);

        auto itrB = d[in] == 0 ? upper_bound(ad[2].begin(),  ad[2].end(),  a[in])
                               : upper_bound(ad[3].begin(),  ad[3].end(), -a[in]);

        //auto itrB = lower_bound(ad[d[in]].rbegin(), ad[d[in]].rend(), a[in]);

        if (itrA == ad[d[in] + 1].end()) {
            cout << a[in] + t << endl;
        }
        else if (itrB == ad[d[in] + 2].end()) {
            cout << (d[in] ? min(a[in] - t, (a[in] - *itrA) / 2)
                           : a[in] + min(t, (*itrA - a[in]) / 2))
                 << endl;
        }
        else {
            //左に進む
            if (d[in]) {
                cout << max(-*itrA + abs(*itrA - *itrB) / 2, a[in] - t) << endl;
            }
            else {
                //yosaso
                cout << min((*itrA + max(a[in], -*itrB)) / 2, a[in] + t) << endl;
            }
        }
        /*
        cout << a[in] << " "
             << (itrA == ad[!d[in]].end() ? "va" : to_string(*itrA)) << " "
             << (itrB == ad[d[in]+2].end()  ? "va" : to_string(*itrB)) << endl;
             */
        //if (itr == ad[!d[in]].end()) cout << "va" << endl;
        //else if (d[i] == 0) cout << a[in] << " " << *itr << endl;
        //else cout << -a[in] << " " << *itr << endl;
    }
    return 0;
}

C++: #include <bits/stdc++.h>

#define whole(xs) xs.begin(),xs.end()

using namespace std;

namespace {

    typedef double real;
    typedef long long ll;

    const ll INF = LLONG_MAX / 2LL;

    template<class T> ostream& operator<<(ostream& os, const vector<T>& vs) {
        if (vs.empty()) return os << "[]";
        os << "[" << vs[0];
        for (int i = 1; i < vs.size(); i++) os << " " << vs[i];
        return os << "]";
    }
    template<class T> istream& operator>>(istream& is, vector<T>& vs) {
        for (auto it = vs.begin(); it != vs.end(); it++) is >> *it;
        return is;
    }

    struct P {
        int index;
        ll a;
        int d;
        P() {}
        P(int index, ll a, int d) : index(index), a(a), d(d) {}
    };
    bool operator<(const P& a, const P& b) {
        return a.a < b.a;
    }

    ll N, T, Q;
    vector<P> X;
    vector<int> I;
    void input() {
        cin >> N >> T >> Q;
        X.clear(); X.resize(N);
        for (int i = 0; i < N; i++) {
            X[i].index = i;
            cin >> X[i].a >> X[i].d;
        }
        I.clear(); I.resize(Q);
        for (int i = 0; i < Q; i++) {
            int q; cin >> q; q--;
            I[i] = q;
        }
    }


    void solve() {
        sort(whole(X));
        vector<ll> stop(N);
        vector<P> es;
        ll p = -INF;
        for (int i = 0; i < N; i++) {
            const P& a = X[i];
            if (a.d == 1) {
                es.push_back(a);
            } else {
                if (es.empty()) {
                    stop[a.index] = p;
                } else {
                    ll s = (es.back().a + a.a) / 2;
                    stop[a.index] = s;
                    p = s;
                    for (auto e : es) {
                        stop[e.index] = s;
                    }
                    es.clear();
                }
            }
        }
        for (auto e : es) {
            stop[e.index] = INF;
        }

        for (int q = 0; q < Q; q++) {
            int i = I[q];
            if (X[i].d == 1) {
                cout << min(stop[i], X[i].a + T) << endl;
            } else {
                cout << max(stop[i], X[i].a - T) << endl;
            }
        }

    }
}

int main() {
    input(); solve();
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

#define int long long

const int inf = 1000000000000000019;

int n, t, q;
int a[101010];
bool d[101010];
int l[101010];

main()
{
  cin >> n >> t >> q;
  for (int i = 0; i < n; i++){
    int D;
    cin >> a[i] >> D;
    d[i] = (D - 1 ? true : false);
  }

  for (int i = 0; i < n; i++){
    l[i] = - inf;
  }


  bool f = false;
  for (int i = 0; i < n; i++){
    if (!f && d[i]) {
      l[i] = l[i - 1] = (a[i] + a[i - 1]) / 2;
    } else if (f && d[i]){
      l[i] = l[i - 1];
    }

    f = d[i];
  }

  for (int i = n - 2; i >= 0; i--){
    if (!f && !d[i]) l[i] = l[i + 1];
    f = d[i];
  }


  for (int i = 0; i < q; i++){
    int x;
    cin >> x;
    x--;

    if (abs(a[x] - l[x]) < t){
      cout << l[x] << endl;
      continue;
    }
    cout << a[x] + (d[x] ? -1 : 1) * t << endl;
  }

  for (int i = 0; i < n; i++){
    //cout << l[i] << endl;
  }
}