#include <bits/stdc++.h>
#define endl '\n'

using namespace std;

const int N = 100007;
const int TREE_SIZE = 5000007;
const long long INF = (long long)(1e9) * 1ll * (long long)(1e5) + 7;
const int TO = (1e9);

struct slingshot {
    int x,y,t;
    slingshot(){}
    slingshot(int a, int b, int c): x(a), y(b), t(c) {}
    bool operator <(const slingshot &a) const {
        return x<a.x;
    }
};

struct query {
    int x,y,idx;
    query(){}
    query(int a, int b, int c): x(a), y(b), idx(c) {}
    bool operator <(const query &a) const {
        return x<a.x;
    }
};

struct segment_tree {
    int nodes_count;
    int left[TREE_SIZE],right[TREE_SIZE];
    long long tree[TREE_SIZE];

    segment_tree() {
        nodes_count=1;
        memset(left,0,sizeof(left));
        memset(right,0,sizeof(right));
        fill(tree,tree+TREE_SIZE,INF);
    }

    void clear() {
        for(int i=1;i<=nodes_count;i++) {
            left[i]=right[i]=0;
            tree[i]=INF;
        }
        nodes_count=1;
    }

    void extend_left(int node) {
        if(left[node]==0) {
            left[node]=++nodes_count;
        }
    }

    void extend_right(int node) {
        if(right[node]==0) {
            right[node]=++nodes_count;
        }
    }

    void update(int a, int b, int pos, int node, long long value) {
        if(a==b) {
            tree[node]=min(tree[node],value);
            return;
        }
        if(pos<=((a+b)>>1)) {
            extend_left(node);
            update(a,(a+b)>>1,pos,left[node],value);
            tree[node]=min(tree[node],tree[left[node]]);
        }
        else {
            extend_right(node);
            update(((a+b)>>1)+1,b,pos,right[node],value);
            tree[node]=min(tree[node],tree[right[node]]);
        }
    }

    void update(int pos, int value) {
        update(0,TO,pos,1,value);
    }

    long long query(int a, int b, int i, int j, int node) {
        if(a>b || a>j || b<i) return INF;
        if(a>=i && b<=j) return tree[node];
        extend_left(node);
        extend_right(node);
        return min(query(a,(a+b)>>1,i,j,left[node]),query(((a+b)>>1)+1,b,i,j,right[node]));
    }

    long long query(int a, int b) {
        return query(0,TO,a,b,1);
    }
};

int n,m;
vector < slingshot > a1,a2;
vector < query > q1,q2;
segment_tree st;
int answer[N];

void solve(vector < slingshot > shots, vector < query > queries) {
    int i,pos;

    sort(shots.begin(),shots.end());
    sort(queries.begin(),queries.end());

    /*
        First case: x, xi, yi, y
        Minimize: y-x+xi+ti-yi   <=>   Minimize: xi+ti-yi
    */
    st.clear();
    pos=(int)(shots.size())-1;
    for(i=(int)(queries.size())-1;i>=0;i--) {
        //Add all relevant shots
        while(pos>=0 && shots[pos].x>=queries[i].x) {
            st.update(shots[pos].y,0ll+shots[pos].x+shots[pos].t-shots[pos].y);
            --pos;
        }

        answer[queries[i].idx]=min(0ll+answer[queries[i].idx],queries[i].y-queries[i].x+st.query(queries[i].x,queries[i].y));
    }

    /*
        Second case: x, xi, y, yi
        Minimize: xi-x+ti+yi-y  <=>  Minimize: -x-y+xi+yi+ti  <=>  Minize: xi+yi+ti
    */
    st.clear();
    pos=(int)(shots.size())-1;
    for(i=(int)(queries.size())-1;i>=0;i--) {
        //Add all relevant shots
        while(pos>=0 && shots[pos].x>=queries[i].x) {
            st.update(shots[pos].y,0ll+shots[pos].x+shots[pos].y+shots[pos].t);
            --pos;
        }

        answer[queries[i].idx]=min(0ll+answer[queries[i].idx],-queries[i].x-queries[i].y+st.query(queries[i].y,TO));
    }

    /*
        Third case: xi, x, yi, y
        Minimize: x-xi+ti+y-yi  <=>  Minimize: x+y+ti-xi-yi  <=>  Minimize:  ti-xi-yi
    */
    st.clear();
    pos=0;
    for(i=0;i<(int)(queries.size());i++) {
        //Add all relevant shots
        while(pos<(int)(shots.size()) && shots[pos].x<=queries[i].x) {
            st.update(shots[pos].y,0ll+shots[pos].t-shots[pos].x-shots[pos].y);
            ++pos;
        }

        answer[queries[i].idx]=min(0ll+answer[queries[i].idx],queries[i].x+queries[i].y+st.query(queries[i].x,queries[i].y));
    }

    /*
        Fourth case: xi, x, y, yi
        Minimize: x-xi+ti+yi-y  <=>  Minimize: x-y+ti+yi-xi  <=>  Minimize: ti+yi-xi
    */
    st.clear();
    pos=0;
    for(i=0;i<(int)(queries.size());i++) {
        //Add all relevant shots
        while(pos<(int)(shots.size()) && shots[pos].x<=queries[i].x) {
            st.update(shots[pos].y,0ll+shots[pos].t+shots[pos].y-shots[pos].x);
            ++pos;
        }

        answer[queries[i].idx]=min(0ll+answer[queries[i].idx],queries[i].x-queries[i].y+st.query(queries[i].y,TO));
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    freopen("slingshot.in","r",stdin);
    freopen("slingshot.out","w",stdout);
    int i,x,y,z;

    scanf("%d %d", &n, &m);
    for(i=1;i<=n;i++) {
        scanf("%d %d %d", &x, &y, &z);
        if(x<=y) {
            a1.push_back(slingshot(x,y,z));
        }
        else {
            a2.push_back(slingshot(y,x,z));
        }
    }
    for(i=1;i<=m;i++) {
        scanf("%d %d", &x, &y);
        answer[i]=abs(x-y);
        if(x<=y) {
            q1.push_back(query(x,y,i));
        }
        else {
            q2.push_back(query(y,x,i));
        }
    }

    solve(a1,q1);
    solve(a2,q2);

    for(i=1;i<=m;i++) {
        printf("%d\n", answer[i]);
    }

    return 0;
}