import java.util.TreeMap;
import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("Test Start!");
		System.out.println("--------------");

		IntervalDataSet data = new IntervalDataSet ();

		data.insert(new Interval( 1,3, 0 ));
		data.insert(new Interval( 2,4, 1 ));
		data.insert(new Interval( 3,5, 3 ));
		data.insert(new Interval( 4,6, 4 ));
        System.out.println("initial values");
        data.print();
        
		System.out.println("--------------");
        System.out.println("Intervals overlapping [2,3]");
        
		data.printOverlappingIntervals(new Interval( 2,3, -1 ));
		System.out.println("--------------");

		System.out.println("change depth 0 to 2");
		data.changeDepth( 0, 2 );
        data.print();
        System.out.println("--------------");

		System.out.println("remove depth 4");
        data.remove( 4 );
        data.print();
        System.out.println("--------------");

		System.out.println("change depth 1 to 4");
        data.changeDepth( 1, 4 );
        data.print();
        System.out.println("--------------");
        
        System.out.println("Test End!");
	}
}

class Interval
{
	public int min;
	public int max;
	public int depth;

	public Interval (int min, int max, int depth)
	{
		this.min = min;
		this.max = max;
		this.depth = depth;
	}

	public boolean intersect (Interval b)
	{
		return (b != null
			&& ((this.min >= b.min && this.min <= b.max)
				|| (this.max >= b.min && this.max <= b.max))
			);
	}
	
	public void print ()
    {
        System.out.println(depth+" => ["+min+","+max+"] ");
    }
}

class IntervalDataSet
{
	private TreeMap<Integer,Interval> map;

	public IntervalDataSet ()
	{
		map = new TreeMap<Integer,Interval> ();
	}

    public void print ()
    {
        for(Map.Entry<Integer,Interval> entry : map.entrySet())
        {
          Integer key = entry.getKey();
          Interval value = entry.getValue();
    
          System.out.println(key+" => ["+value.min+","+value.max+"] ");
        }
    }

	public boolean changeDepth (int depth, int newDepth)
	{
		if (!map.containsKey(depth)) return false;

		if (map.containsKey(newDepth)) return false;

		Interval in = map.get(depth);

		in.depth = newDepth;

		remove(depth); insert(in);

        return true;
	}

	public boolean insert (Interval in)
	{
		if (in == null) return false;

		if (map.containsKey(in.depth)) return false;

		map.put(in.depth, in); return true;
	}

	public boolean remove (int depth)
	{
		if (!map.containsKey(depth)) return false;

		map.remove(depth); return true;
	}

    public Interval get (int depth)
    {
        return map.get(depth);
    }

    public void print (int depth)
    {
        if (!map.containsKey(depth))
          System.out.println(depth+" => X ");
        else
          System.out.println(depth+" => ["
            +map.get(depth).min+","+map.get(depth).max+"] ");
    }
    
    public void printOverlappingIntervals (Interval in)
    {
        for (Interval interval : map.values())
            if (interval.intersect(in))
                interval.print();
    }

    public ArrayList<Interval> getOverlappingIntervals (Interval in)
    {
        ArrayList<Interval> list = new ArrayList<Interval>();

        for (Interval interval : map.values())
            if (interval.intersect(in))
                list.add(interval);

        return list;
    }

    public int size ()
	{
		return map.size();
	}
}