Problem: The m-floor (m > 1) office of international corporation CodeForces has the advanced elevator control system established. It works as follows.

All office floors are sequentially numbered with integers from 1 to m. At time t = 0, the elevator is on the first floor, the elevator is empty and nobody is waiting for the elevator on other floors. Next, at times ti (ti > 0) people come to the elevator. For simplicity, we assume that one person uses the elevator only once during the reported interval. For every person we know three parameters: the time at which the person comes to the elevator, the floor on which the person is initially, and the floor to which he wants to go.

The movement of the elevator between the floors is as follows. At time t (t ≥ 0, t is an integer) the elevator is always at some floor. First the elevator releases all people who are in the elevator and want to get to the current floor. Then it lets in all the people waiting for the elevator on this floor. If a person comes to the elevator exactly at time t, then he has enough time to get into it. We can assume that all of these actions (going in or out from the elevator) are made instantly. After that the elevator decides, which way to move and at time (t + 1) the elevator gets to the selected floor.

The elevator selects the direction of moving by the following algorithm. 

  * If the elevator is empty and at the current time no one is waiting for the elevator on any floor, then the elevator remains at the current floor. 
  * Otherwise, let's assume that the elevator is on the floor number x (1 ≤ x ≤ m). Then elevator calculates the directions' "priorities" pup and pdown: pup is the sum of the number of people waiting for the elevator on the floors with numbers greater than x, and the number of people in the elevator, who want to get to the floors with the numbers greater than x; pdown is the sum of the number of people waiting for the elevator on the floors with numbers less than x, and the number of people in the elevator, who want to get to the floors with the numbers less than x. If pup ≥ pdown, then the elevator goes one floor above the current one (that is, from floor x to floor x + 1), otherwise the elevator goes one floor below the current one (that is, from floor x to floor x - 1). 



Your task is to simulate the work of the elevator and for each person to tell the time when the elevator will get to the floor this person needs. Please note that the elevator is large enough to accommodate all the people at once.

Input

The first line contains two space-separated integers: n, m (1 ≤ n ≤ 105, 2 ≤ m ≤ 105) — the number of people and floors in the building, correspondingly.

Next n lines each contain three space-separated integers: ti, si, fi (1 ≤ ti ≤ 109, 1 ≤ si, fi ≤ m, si ≠ fi) — the time when the i-th person begins waiting for the elevator, the floor number, where the i-th person was initially located, and the number of the floor, where he wants to go.

Output

Print n lines. In the i-th line print a single number — the moment of time, when the i-th person gets to the floor he needs. The people are numbered in the order, in which they are given in the input. 

Please don't use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.

Examples

Input

3 10
1 2 7
3 6 5
3 4 8


Output

7
11
8


Input

2 10
1 2 5
7 4 5


Output

5
9

Note

In the first sample the elevator worked as follows: 

  * t = 1. The elevator is on the floor number 1. The elevator is empty. The floor number 2 has one person waiting. pup = 1 + 0 = 1, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 2. 
  * t = 2. The elevator is on the floor number 2. One person enters the elevator, he wants to go to the floor number 7. pup = 0 + 1 = 1, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 3. 
  * t = 3. The elevator is on the floor number 3. There is one person in the elevator, he wants to go to floor 7. The floors number 4 and 6 have two people waiting for the elevator. pup = 2 + 1 = 3, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 4. 
  * t = 4. The elevator is on the floor number 4. There is one person in the elevator who wants to go to the floor number 7. One person goes into the elevator, he wants to get to the floor number 8. The floor number 6 has one man waiting. pup = 1 + 2 = 3, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 5. 
  * t = 5. The elevator is on the floor number 5. There are two people in the elevator, they want to get to the floors number 7 and 8, correspondingly. There is one person waiting for the elevator on the floor number 6. pup = 1 + 2 = 3, pdown = 0 + 0 = 0, pup ≥ pdown. So the elevator goes to the floor number 6. 
  * t = 6. The elevator is on the floor number 6. There are two people in the elevator, they want to get to the floors number 7 and 8, correspondingly. One man enters the elevator, he wants to get to the floor number 5. pup = 0 + 2 = 2, pdown = 0 + 1 = 1, pup ≥ pdown. So the elevator goes to the floor number 7. 
  * t = 7. The elevator is on the floor number 7. One person leaves the elevator, this person wanted to get to the floor number 7. There are two people in the elevator, they want to get to the floors with numbers 8 and 5, correspondingly. pup = 0 + 1 = 1, pdown = 0 + 1 = 1, pup ≥ pdown. So the elevator goes to the floor number 8. 
  * t = 8. The elevator is on the floor number 8. One person leaves the elevator, this person wanted to go to the floor number 8. There is one person in the elevator, he wants to go to the floor number 5. pup = 0 + 0 = 0, pdown = 0 + 1 = 1, pup < pdown. So the elevator goes to the floor number 7. 
  * t = 9. The elevator is on the floor number 7. There is one person in the elevator, this person wants to get to the floor number 5. pup = 0 + 0 = 0, pdown = 0 + 1 = 1, pup < pdown. So the elevator goes to the floor number 6. 
  * t = 10. The elevator is on the floor number 6. There is one person in the elevator, he wants to get to the floor number 5. pup = 0 + 0 = 0, pdown = 0 + 1 = 1, pup < pdown. So the elevator goes to the floor number 5. 
  * t = 11. The elevator is on the floor number 5. One person leaves the elevator, this person initially wanted to get to the floor number 5. The elevator is empty and nobody needs it, so the elevator remains at the floor number 5. 

Solution (in JAVA):

Solution:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class TC
{
    static int n, m;
    static Person[] ppl;
    static TreeMap<Integer,ArrayList<Integer>> waiting;
    static long[] res;
    static TreeMap<Integer, ArrayList<Integer>> entry, exit;
    static SegmentTree priority;
    
    static void simulate() throws IOException
    {
        res=new long[n+1];
        int cnt=0;
        long currTime=0;
        int currFloor=1;
        entry=new TreeMap();
        exit=new TreeMap();
        int[] t=new int[m+1];
        Arrays.fill( t,0);
        priority=new SegmentTree( t );
        
        while( cnt<n )
        {
            // Anyone exiting ?
            if( exit.containsKey(currFloor))
            {
                ArrayList<Integer> plist=exit.get(currFloor);
                int tot=0;
                for( int x:plist )
                {
                    tot++;
                    cnt++;
                    res[x]=currTime;
                    if( cnt==n )
                        break;
                }
                priority.updateDiff(currFloor, -tot);
                exit.remove( currFloor );
            }
            
            // Any new person waiting ? 
            if( waiting.containsKey( (int)currTime))
            {
                ArrayList<Integer> plist=waiting.get( (int)currTime);
                for( int x:plist )
                {
                    Person p=ppl[x];
                    priority.updateDiff(p.sf, +1);
                    if( !entry.containsKey( p.sf))
                        entry.put( p.sf, new ArrayList() );
                    ArrayList<Integer> temp=entry.get( p.sf );
                    temp.add( x );
                    entry.put( p.sf, temp );
                }
            }
            
            // Anyone entering ?
            if( entry.containsKey(currFloor))
            {
                ArrayList<Integer> plist=entry.get(currFloor);
                int tot=0;
                for( int x:plist )
                {
                    tot++;
                    Person p=ppl[x];
                    int dest=p.df;
                    priority.updateDiff(dest, +1);
                    if( !exit.containsKey(dest))
                        exit.put( dest,new ArrayList() );
                    ArrayList<Integer> temp=exit.get( dest );
                    temp.add( x );
                    entry.remove( currFloor );
                    exit.put( dest, temp );
                }
                priority.updateDiff(currFloor, -tot);
            }
            
          
            // Get new lift direction
            int up=priority.RMQ(currFloor+1, m);
            int down=priority.RMQ( 1, currFloor-1 );
            up = Math.max( 0, up );
            down=Math.max( 0, down );
            
            if( up >= down )
            {
                int nextEntry=Integer.MAX_VALUE, nextExit=Integer.MAX_VALUE, nextWait=Integer.MAX_VALUE;
                
                if( ( !entry.isEmpty() ) && ( entry.lastKey() > currFloor ) )
                    nextEntry=entry.higherKey(currFloor);
                if( ( !exit.isEmpty() ) && ( exit.lastKey() > currFloor ) )
                    nextExit=exit.higherKey( currFloor );
                
                int floorDiff = Integer.MAX_VALUE;
                
                if( Math.min( nextEntry, nextExit ) != Integer.MAX_VALUE )
                    floorDiff=Math.min( nextEntry, nextExit )-currFloor;
                
                int timeDiff=Integer.MAX_VALUE;
                if(( !waiting.isEmpty()) && ( waiting.lastKey() > currTime ) )
                {
                    nextWait=waiting.higherKey( (int)currTime );
                    timeDiff=nextWait-(int)currTime;
                }
                
                currTime+=Math.min( floorDiff, timeDiff );
                               
                if( up + down != 0 )
                    currFloor+=Math.min( floorDiff, timeDiff );
            }
                
            else
            {
                int nextEntry=Integer.MAX_VALUE, nextExit=Integer.MAX_VALUE, nextWait=-1;
                
                if( ( !entry.isEmpty() ) && ( entry.firstKey() < currFloor ) )
                    nextEntry=entry.lowerKey(currFloor);
                if( ( !exit.isEmpty() ) && ( exit.firstKey() < currFloor ) )
                    nextExit=exit.lowerKey( currFloor );
                
                int floorDiff = Integer.MAX_VALUE;
                
                if( Math.min( nextEntry, nextExit ) != Integer.MAX_VALUE )
                {
                    if( Math.max( nextEntry, nextExit ) != Integer.MAX_VALUE )
                    {
                        floorDiff=currFloor-Math.max( nextEntry, nextExit );
                    }
                    
                    else
                        floorDiff=currFloor-Math.min( nextEntry, nextExit );    
                }
                
                int timeDiff=Integer.MAX_VALUE;
                if(( !waiting.isEmpty()) && ( waiting.lastKey() > currTime ) )
                {
                    nextWait=waiting.higherKey( (int)currTime );
                    timeDiff=nextWait-(int)currTime;
                }
                
                currTime+=Math.min( floorDiff, timeDiff );
                               
                if( up + down != 0 )
                    currFloor-=Math.min( floorDiff, timeDiff );
            }
        }
        
        BufferedWriter out=new BufferedWriter( new OutputStreamWriter( System.out ));
        for( int i=1; i<=n; i++ )
        {
            out.write( Long.toString(res[i] ) + "\n");
        }
        out.close();
    }
    
    public static void main( String[] args ) throws IOException
    {
        BufferedReader br=new BufferedReader( new InputStreamReader(System.in));
        String s=br.readLine();
        StringTokenizer tok=new StringTokenizer(s);
        
        n=Integer.parseInt(tok.nextToken());
        m=Integer.parseInt(tok.nextToken());
        ppl=new Person[n+1];
        waiting=new TreeMap();
        
        for( int i=1; i<=n; i++ )
        {
            s=br.readLine();
            tok=new StringTokenizer(s);
            int ti=Integer.parseInt(tok.nextToken());
            int si=Integer.parseInt(tok.nextToken());
            int fi=Integer.parseInt(tok.nextToken());
            ppl[i]=new Person(ti,si,fi);
            if( !waiting.containsKey(ti))
            {
                ArrayList<Integer> temp=new ArrayList();
                temp.add(i);
                waiting.put(ti, temp);
            }
            else
            {
                ArrayList<Integer> temp=waiting.get( ti );
                temp.add(i);
                waiting.put(ti, temp);
            }
            
        }
        
        simulate();
    }
}

class Person
{
    int st;
    int sf, df;
    
    public Person( int st, int sf, int df )
    {
        this.st=st;
        this.sf=sf;
        this.df=df;
    }
}
class SegmentTree{


    private int[] arr;
    private int[] s_tree;
    private int n;

    public void printTree()
    {
        for( int i=0; i<s_tree.length; i++ )
        {
            System.out.print( s_tree[ i ] + " ");
        }
        System.out.println();
    }

    private void fillTree( ){

        double logne = Math.log( n );
        double log2e = Math.log( 2 );

        double logn_ceil = ( int ) Math.ceil( logne / log2e );

        int length =  2*( ( int ) Math.pow( 2, logn_ceil ));
        s_tree = new int[ length ];

        Arrays.fill( s_tree, 0 );

        initialize( 0, n-1, 1 );

    }

    private void initialize( int a, int b, int i ){


        if( a>b )
            return;

        if( a==b )
        {
            s_tree[ i ] = arr[ b ];
            return;
        }

        int mid = ( a + b )/2;

        initialize( a, mid, 2*i );
        initialize( mid+1, b, 2*i + 1 );


       // if(  arr[ s_tree[ 2*i ] ] <  arr[ s_tree[ 2*i+1 ] ] )
           s_tree[ i ] = s_tree[ 2*i ] + s_tree[ 2*i + 1 ];

//       else
           // s_tree[ i ] = s_tree[ 2*i + 1 ];

    }

    public int RMQ( int a, int b )
    {
        return query( a, b, 0, n-1, 1 );
    }

    public void updateDiff( int index, int diff ){

        // int add = newValue - arr[ index ]; // amount added to the node
        arr[ index ] +=diff;
        updateTree( index, diff, 0, n-1, 1 );
    }
    
    private void updateTree( int i, int add, int r1, int r2, int curr_i ){


        s_tree[ curr_i ]+= add;

        // now find which child to take

        if( r1 == r2 )
            return;

        int mid = ( r1 + r2 ) / 2;

        if( i<=mid )
            updateTree( i, add, r1, mid, 2*curr_i );

        else
            updateTree( i, add, mid+1, r2, 2*curr_i + 1 );

    }

    // a, b -> query ranges
    // i -> current node of segment tree
    // r1, r2 -> ranges represented by node i

    private int query( int a, int b, int r1, int r2, int i ){

        if( a>b )
            return 0;

        if( a==b )
            return arr[ a ]; /// change as reqd, associate with array

        if( ( a==r1 ) && ( b==r2 ) )
            return s_tree[ i ] ;

        if( ( a>r2 ) || ( b<r1 ))
            return 0;


       int mid = ( r1 + r2 )/2;

       // check if it lies completely in one child node

       if( a>mid )
           return query( a, b, mid+1, r2, 2*i + 1 );

       if( b<mid+1 )
           return query( a, b, r1, mid, 2*i );

       // else split ranges as required

       int res1 = query( a, mid, r1, mid, 2*i );
       int res2 = query( mid+1, b, mid+1, r2, 2*i + 1 );

       return res1+res2;

    }


    public SegmentTree( int[] _arr ){



        n = _arr.length;
        arr = _arr;

        fillTree();

        /* for( int temp : s_tree )
            System.out.print( temp + " " );

        System.out.println(); */
    }

    }

/*public class directx{

        public static void main( String[] args ) throws IOException
    {
        Scanner s = new Scanner( System.in );
        int n = s.nextInt();
        int[] arr = new int[ n ];

        for( int i=0; i<n; i++ )
        {
            arr[ i ] = s.nextInt();
        }

        SegmentTree tree = new SegmentTree( arr );
        tree.printTree();

        while( true )
        {
            int a = s.nextInt();
            int b = s.nextInt();
            tree.update(a, b );
            tree.printTree();
        }



    }  

} */