//I am now using my improved code to try more strategic scenarios
//I am aiming to push my code to reach these notations
//M=merged (it would be due to  [2,2],  [2,2])
//]  = no merge (just stored)
//]A = ascending merge   [5,9],  [6,12]  or   [5,9],[9,9] or  [5,9],[8,9]
//]D = descending merge  [9,5], [4,3]    or    [9,5],[5,4] or  [9,5],[4,5]
//]S = where both merges have exact same values [2,2], [2,2]    or    [4,4],[4,4] 
    //it will not be transparent in intermediate contexts such as [2, 2], [2, 7], [2, 7]  since [2,7] merging all will take precedence
    //but I have included a counter after it [X,X][X,X]s...  to denote that it has occured twice....
    //in future I can look to extend notation if  there are repetitions of  [2,7],[2,7],  but for now kept it simple  

//ALSO CAN endNewInterval be phased out, used in small section of code only.....
//leaving it for now to avoid any confusion....

//USE this code in any areas where troubleshooting is required to speed up the process
/*
//**REPEAT CODE //***********
System.out.println("start interval: " + startInterval);
System.out.println("end interval: " + endInterval);
System.out.println("start interval second range: " + startIntervalSecondRange);
System.out.println("end interval second range: " + endIntervalSecondRange);
System.out.println("start interval first range: " + startIntervalFirstRange);
System.out.println("end interval first range: " + endIntervalFirstRange);
System.out.println ("Last item innerlist: " + lastItemInnerList);

*/

import java.util.*;
public class Solution 
{
    public static void main (String[] args)
    {
        List<List<Object>> intervals = new ArrayList<>();
            
        List<Object> entries = new ArrayList<>();
            
        //TEST CASE 1  -  PASS
        //entries.add("[1, 3]");
            
        //TEST CASE 2 - No issues     PASS
        //entries.add("[1, 3]");
        //entries.add("[4, 7]");
            
        //TEST CASE 3 - No issues     PASS
        //entries.add("[1, 3]");
        //entries.add("[2, 7]");
            
        //TEST CASE 4 - No issues-   PASS
        //entries.add("[1, 3]");
        //entries.add("[4, 7]");
        //entries.add("[8, 9]");
            
        //TEST CASE 5 - No issues    PASS
        //entries.add("[1, 3]");
        //entries.add("[2, 7]");
        //entries.add("[8, 9]");
            
        // I CAN SEE, AS THE OBJECTS HIT 4, SIMILAR TO MY OTHER CODE, THE RESULTS WERE SKEWED....
            
        //TEST CASE 6 - No issues    PASS
        //entries.add("[1, 3]");
        //entries.add("[4, 7]");
        //entries.add("[8, 10]");
        //entries.add("[11, 25]");
        
        //TEST CASE 7 - No issues    //PASS
        //entries.add("[1, 3]");
        //entries.add("[4, 7]");
        //entries.add("[8, 10]");
        //entries.add("[11, 25]");
        //entries.add("[27, 33]");
        //entries.add("[35, 38]");
        //entries.add("[42, 47]");
            
        //TEST CASE 8  PASS    UP TO HERE-----
        //entries.add("[1, 3]");
        //entries.add("[2, 7]");
        //entries.add("[6, 10]");
        
        //TEST CASE 8  PASS    UP TO HERE-----   PASS
        //entries.add("[2, 2]");
        //entries.add("[3, 3]");
        //entries.add("[4, 4]");
        
        //TEST CASE 8  PASS    UP TO HERE-----   PASS
        //entries.add("[2, 2]");
        //entries.add("[2, 2]");
        
        //TEST CASE 8  PASS    UP TO HERE-----   PASS-----------------------------------
        //entries.add("[2, 2]");
        //entries.add("[3, 3]");
        //entries.add("[3, 3]");
        //entries.add("[3, 3]");
        
        
        //TEST CASE 8  PASS    UP TO HERE-----   PASS-----------------------------------
        //entries.add("[2, 2]");
        //entries.add("[2, 2]");
        //entries.add("[2, 2]");
        //entries.add("[3, 3]");
        //entries.add("[3, 3]");
        
        
        
        //TEST CASE 8  PASS    UP TO HERE-----   *******************  PASS
        //entries.add("[4, 8]");
        //entries.add("[2, 2]");
        //entries.add("[2, 2]");
        
        //TEST CASE 9 -                 PASS
        //entries.add("[1, 3]");
        //entries.add("[2, 7]");
        //entries.add("[6, 10]");
        //entries.add("[9, 25]");
        //entries.add("[24, 33]");
        //entries.add("[30, 38]");
        //entries.add("[34, 44]");
        
        //TEST CASE 10                  PASS 
        //entries.add("[1, 3]");
        //entries.add("[4, 7]");
        //entries.add("[6, 9]");
        //entries.add("[8, 25]");
        
        //TEST CASE 11                PASS
        //entries.add("[1, 3]");
        //entries.add("[2, 7]");
        //entries.add("[6, 10]");
        //entries.add("[19, 45]");
        //entries.add("[40, 52]");
        //entries.add("[58, 61]");
        
        //TEST CASE 12 - Invalid data   (same interval first two objects) - - seems satisfactory output
        //FAIL:
        //Since there was exact overlap between  [1,3] and [3,9], the startInterval has become 3
        //need to change this logic
        
        //entries.add("[1, 3]");
        //entries.add("[3, 9]");
        //entries.add("[8, 9]");
            
        //TEST CASE 13 - Invalid data   (same interval first two objects) - seems satisfactory output
        //entries.add("[1, 3]");
        //entries.add("[3, 9]");
        //entries.add("[8, 12]");
        //entries.add("[12, 15]");
        
        //TEST CASE 14 - Invalid data  - seems semantically correct
        //entries.add("[1, 3]");
        //entries.add("[4, 9]");
        //entries.add("[8, 2]");
        //entries.add("[9, 2]");
        
        //TEST CASE 15 - undocumented  (same ranges) - seems satisfactory output
        //entries.add("[1, 3]");
        //entries.add("[1, 3]");
        
        //I am now using my improved code to try more strategic scenarios
        //I am aiming to push my code to reach these notations
        //M=merged (it would be due to  [2,2],  [2,2])
        //]  = no merge (just stored)
        //]A = ascending merge   [5,9],  [6,12]  or   [5,9],[9,9] or  [5,9],[8,9]
        //]D = descending merge  [9,5], [4,3]    or    [9,5],[5,4] or  [9,5],[4,5]   
        
        //TEST CASE 16 => using a repeat entry   
        //this keeps both entries intact, not performed a merge
        //entries.add("[2, 2]");
        //entries.add("[2, 2]");
        
        //TEST CASE 17 => using ascending
        //entries.add("[2, 2]");
        //entries.add("[2, 7]");
        
        //TEST CASE 17 => using ascending
        //entries.add("[2, 2]");
        //entries.add("[2, 7]");
        //entries.add("[7, 3]");
        
          //TEST CASE 17 => using ascending
        //entries.add("[2, 2]");
        //entries.add("[2, 7]");
        //entries.add("[7, 3]");
        //entries.add("[3, 3]");
        
        //TEST CASE 18 => using ascending
        //entries.add("[2, 2]");
        //entries.add("[2, 7]");
        //entries.add("[4, 7]");
        //entries.add("[3, 3]");
        //entries.add("[2, 9]");
        //entries.add("[10, 10]");
        
        
        //TEST CASE 18 => using ascending
        //entries.add("[2, 7]");
        //entries.add("[3, 3]");
        
        
        //TEST CASE 18 => using DESCENDING.....
        //entries.add("[7, 7]");
        //entries.add("[7, 4]");
        //entries.add("[3, 4]");
        
        //TEST CASE 18 => using ascending
        //entries.add("[2, 2]");
        //entries.add("[2, 7]");
        //entries.add("[4, 7]");
        
        //TEST CASE 19 => mixed
        //entries.add("[2, 2]");
        //entries.add("[2, 7]");
        //entries.add("[4, 7]");
        //entries.add("[2, 2]");
        //entries.add("[2, 7]");
        //entries.add("[4, 7]");
        
        
        //TEST CASE 18 => using ascending
        //entries.add("[2, 2]");
        //entries.add("[2, 2]");
        
        //TEST CASE 17 => using a non-descending scenario - I will add no notations at the end....
        //entries.add("[8, 5]");
        //entries.add("[7, 3]"); 
        
        //TEST CASE 18 => using a ascending scenario - I will add reference into the item
        //not sure if it will always be ascending passing through this area....
        //entries.add("[3, 7]");
        //entries.add("[5, 8]");  //asc
        
        //TEST CASE 19 => using ascending and descending
        //entries.add("[3, 7]");  
        //entries.add("[5, 8]");  //ascending
        //entries.add("[6, 4]");  //descending
        
        //TEST CASE 20 => using ascending and descending but matching intervals (FAIL)
        //entries.add("[3, 7]");  
        //entries.add("[5, 5]");  
        //entries.add("[4, 3]");  
        
        
        //TEST CASE 21 => using ascending and descending
        //entries.add("[6, 5]");  
        //entries.add("[5, 8]");  //ascending
        //entries.add("[6, 4]");  //no merge
        
        //TEST CASE 22 => using ascending and descending
        //entries.add("[6, 5]");  
        //entries.add("[5, 4]");  //desc
        //entries.add("[3, 2]");  //desc
        //entries.add("[1, 1]");  //desc
        
        
         //TEST CASE 23 => using ascending and descending
        //entries.add("[6, 5]");  
        //entries.add("[4, 5]");  //desc
        //entries.add("[3, 2]");  //desc
        //entries.add("[1, 5]");  //no merge
        
        intervals.add(entries);
            
        System.out.println("Final outer list: " + mergeIntervals(intervals));
    }
    
    public static List<List<Object>> mergeIntervals(List<List<Object>> intervals) 
    {
        Object lastItemInnerList="";
        int inc=1;
        
        String startInterval="";
        
        List<List<Object>> outerList = new ArrayList<>();

        List<Object> innerList = new ArrayList<>();  

        int counter=0;
        
        String mergeDirection="";
        
        String newInterval="";
        
        int numberObjects=0;
        String range;
                
        String startIntervalFirstRange="";
        String endIntervalFirstRange="";
        
        String startIntervalSecondRange="";
        String endIntervalSecondRange="";
        
        String endInterval="";
        
        Iterator<List<Object>> it = intervals.iterator();

        for (List <Object> tt: intervals)
        {
            for (Object s:tt)
            {
                numberObjects++;
            }
            
            for (Object s:tt)
            {
                counter++;
                System.out.println("\nTHIS IS OBJECT: " + s +  " Counter: " + counter);
                System.out.println("repetition: " + inc);
                    
                range = String.valueOf(s);
                
                if (numberObjects==1)
                {
                    startIntervalFirstRange = range.substring(1, range.indexOf(","));
                    
                    endIntervalFirstRange = range.substring(range.indexOf(" ")+1,range.indexOf("]"));
                    
                    newInterval = "["+startIntervalFirstRange+","+ " " + endIntervalFirstRange+"]";
                    innerList.add(newInterval);
                    System.out.println("1Added into innerlist: " + innerList);
                }
                
                if (counter>2)
                {   
                    String endNewInterval = newInterval.substring(newInterval.indexOf(" ")+1, newInterval.indexOf("]"));
                    
                    startIntervalFirstRange = range.substring(1, range.indexOf(","));
                    System.out.println("start interval first range:" + startIntervalFirstRange);
                    
                    endIntervalFirstRange = range.substring(range.indexOf(" ")+1,range.indexOf("]"));
                    
                    System.out.println("2end interval first range:" + endIntervalFirstRange);
                   
                    System.out.println("2end new Interval :" + endNewInterval);
                    
                    if (Integer.valueOf(startIntervalFirstRange)<=Integer.valueOf(endNewInterval))
                    {
                        lastItemInnerList = innerList.get(innerList.size()-1);
                        System.out.println("Last item inner list: " + lastItemInnerList);
                        
                        startInterval = String.valueOf(lastItemInnerList).substring(1,String.valueOf(lastItemInnerList).indexOf(","));
                        endInterval = String.valueOf(lastItemInnerList).substring(String.valueOf(lastItemInnerList).indexOf(" ")+1,String.valueOf(lastItemInnerList).indexOf("]"));
                        
                        if (startInterval=="" || endIntervalSecondRange=="")
                        {
                            startInterval=startIntervalFirstRange;
                            endInterval=endIntervalFirstRange;
                        }
                        
    if ((Integer.valueOf(endIntervalFirstRange)>=Integer.valueOf(endInterval)  && Integer.valueOf(endIntervalFirstRange)>=Integer.valueOf(startInterval))  
    ||  (Integer.valueOf(endIntervalFirstRange)<=Integer.valueOf(endInterval)  && Integer.valueOf(endIntervalFirstRange)<=Integer.valueOf(startInterval)))
                        {
                            mergeDirection="";
                            
                            
                            System.out.println("gg:" + endIntervalFirstRange);
                            System.out.println("hh:" + startInterval);
                            
                            //if ((Integer.valueOf(endIntervalFirstRange))>=Integer.valueOf(startIntervalFirstRange))
                            //{
                            
                            if (Integer.valueOf(endIntervalFirstRange)>=Integer.valueOf(endInterval)  && (Integer.valueOf(endIntervalFirstRange)!=Integer.valueOf(startIntervalFirstRange)) && (Integer.valueOf(endIntervalFirstRange)>Integer.valueOf(startInterval)))
                            {
                                System.out.println("ascending");
                                mergeDirection="A";
                            }
                            
                            if (Integer.valueOf(endIntervalFirstRange)<=Integer.valueOf(endInterval)&& (Integer.valueOf(endIntervalFirstRange)!=Integer.valueOf(startIntervalFirstRange)) && (Integer.valueOf(endIntervalFirstRange)<Integer.valueOf(startInterval)))
                            {
                                System.out.println("descending");
                                mergeDirection="D";
                            }
                            
                          
                          if ((Integer.valueOf(endIntervalFirstRange))>=Integer.valueOf(startIntervalFirstRange))
                            {
                            
                        //}
                            System.out.println("1Removed last item from innerList: " + innerList.get(innerList.size()-1));
                            innerList.remove(innerList.size()-1);
                            
                            if (Integer.valueOf(startInterval)!=Integer.valueOf(startIntervalSecondRange))
                            {
                                //demonstrates that [2,2],[2,2],[3,3],[3,3]
                                //need to reset inc
                                inc=1;
                                System.out.println("reset repetition count-----------");
                                
                                if (Integer.valueOf(startIntervalFirstRange)==Integer.valueOf(startInterval) && Integer.valueOf(endIntervalFirstRange)==Integer.valueOf(endInterval))
                                {
                                    mergeDirection="S";
                                }
                            }
                            
                            
                            System.out.println("start interval: " + startInterval);
System.out.println("3333333end interval: " + endInterval);
System.out.println("start interval second range: " + startIntervalSecondRange);
System.out.println("end interval second range: " + endIntervalSecondRange);
System.out.println("start interval first range: " + startIntervalFirstRange);
System.out.println("end interval first range: " + endIntervalFirstRange);
System.out.println("last item inner List: " + lastItemInnerList);

if (startIntervalSecondRange!="" && endIntervalSecondRange!="")
{
if ((Integer.valueOf(startIntervalFirstRange)==Integer.valueOf(startIntervalSecondRange)) && (Integer.valueOf(endIntervalFirstRange)==Integer.valueOf(endIntervalSecondRange)))
{
    System.out.println("GET HERE: " + inc);
    mergeDirection="S";
    inc++;
}
}

//System.out.println("sssssss:" + lastItemInnerList);
startInterval= String.valueOf(lastItemInnerList).substring(1, String.valueOf(lastItemInnerList).indexOf(","));
System.out.println("WHAT: " + startInterval);
System.out.println("mergeDirection: " + mergeDirection);

if (mergeDirection=="S")
{
    if (inc==1)
    {
        inc++;
    }
    
newInterval = "["+startInterval+","+ " " + endIntervalFirstRange+"]"+mergeDirection+"("+inc+")";
}
else
{
    newInterval = "["+startInterval+","+ " " + endIntervalFirstRange+"]"+mergeDirection;
}
//at this point we are checking if previous item is the same for instance [2,2], [3,3], [3,3]
//it can add suffix S


innerList.add(newInterval);
                            
                            System.out.println("33Added into Inner List: " + newInterval);
                            System.out.println("This is innerlist: " + innerList);
                            //System.exit(0);
                            }
                            
                        }
                        else
                        {
                            if ((endIntervalFirstRange==startIntervalFirstRange) && (Integer.valueOf(endIntervalFirstRange)>Integer.valueOf(endInterval)))
                            {
                        newInterval = "["+startIntervalFirstRange+","+ " " + endIntervalFirstRange+"]";
                        innerList.add(newInterval);
                        System.out.println("2Added into Inner List: " + newInterval);
                            }
                        }
                    }
                    else
                    {
                        newInterval = "["+startIntervalFirstRange+","+ " " + endIntervalFirstRange+"]";
                        innerList.add(newInterval);
                        System.out.println("11Added into Inner List: " + newInterval);
                    }
                }
                if (counter<=2)
                {
                    if (counter==1)
                    {
                        startIntervalFirstRange = range.substring(1, range.indexOf(","));
                        endIntervalFirstRange = range.substring(range.indexOf(" ")+1,range.indexOf("]"));
                    }
                
                    if (counter==2)
                    {
                        startIntervalSecondRange = range.substring(1, range.indexOf(","));
                        
                        endIntervalSecondRange = range.substring(range.indexOf(" ")+1,range.indexOf("]"));
                        
                        if (Integer.valueOf(endIntervalFirstRange)>Integer.valueOf(startIntervalSecondRange))
                        {
                            
    if ((Integer.valueOf(endIntervalSecondRange)>=Integer.valueOf(endIntervalFirstRange)  && Integer.valueOf(endIntervalSecondRange)>=Integer.valueOf(startIntervalFirstRange))  
    ||  (Integer.valueOf(endIntervalSecondRange)<=Integer.valueOf(endIntervalFirstRange)  && Integer.valueOf(endIntervalSecondRange)<=Integer.valueOf(startIntervalFirstRange)))
                            {
                                mergeDirection="";
                                
                                //**REPEAT CODE //***********
                        System.out.println("start interval: " + startInterval);
                        System.out.println("end interval: " + endInterval);
                        System.out.println("start interval second range: " + startIntervalSecondRange);
                        System.out.println("end interval second range: " + endIntervalSecondRange);
                        System.out.println("start interval first range: " + startIntervalFirstRange);
                        System.out.println("1end interval first range: " + endIntervalFirstRange);
                        
                       // [1,3]   [2,7]
                                
                         //                                    3                                     7                                3                  1                                            3                                        2
                                if (Integer.valueOf(endIntervalSecondRange)>=Integer.valueOf(endIntervalFirstRange)  && (endIntervalSecondRange!=startIntervalSecondRange)  &&(Integer.valueOf(endIntervalSecondRange)>Integer.valueOf(startIntervalFirstRange)))  
                                {
                                mergeDirection="A";
                                }
                            
                                if (Integer.valueOf(endIntervalSecondRange)<=Integer.valueOf(endIntervalFirstRange)&& (Integer.valueOf(endIntervalSecondRange)!=Integer.valueOf(startIntervalSecondRange))  &&(Integer.valueOf(endIntervalSecondRange)<Integer.valueOf(startIntervalFirstRange)))  
                                {
                                    mergeDirection="D";
                                }
                                
                                if (innerList.size()>0)
                                {
                                    System.out.println("2Removed last item from innerList: " + innerList.get(innerList.size()-1));
                        
                                    innerList.remove(innerList.size()-1);
                                }
                        
                                newInterval = "["+startIntervalFirstRange+","+ " " + endIntervalSecondRange+"]"+mergeDirection;
                                innerList.add(newInterval);
                                System.out.println("3Added into Inner List: " + newInterval);
                                System.out.println("This is innerlist: " + innerList);
                            }
                            else
                            {
                                
                                System.out.println("start interval: " + startInterval);
                                System.out.println("end interval: " + endInterval);
                                System.out.println("start interval second range: " + startIntervalSecondRange);
                                System.out.println("end interval second range: " + endIntervalSecondRange);
                                System.out.println("start interval first range: " + startIntervalFirstRange);
                                System.out.println("end interval first range: " + endIntervalFirstRange);
                                
                                
                                if ((Integer.valueOf(endIntervalSecondRange)==Integer.valueOf(startIntervalSecondRange) && (Integer.valueOf(endIntervalFirstRange)>Integer.valueOf(endIntervalSecondRange))))
                                {
                                    newInterval = "["+startIntervalFirstRange+","+ " " + endIntervalSecondRange+"]";
                                    innerList.add(newInterval);
                                    System.out.println("4Added into Inner List: " + newInterval);
                                    System.out.println("4*****THE INNERLIST: " + innerList);
                                }
                                
                            }
                    
                            startIntervalFirstRange="";
                            endIntervalFirstRange="";
                            startIntervalSecondRange="";
                            endIntervalSecondRange="";
                        }
                        else
                        {
                            //this just double checks there is no overlap, not required in practice
                            //if (Integer.valueOf(endIntervalFirstRange)>=Integer.valueOf(startIntervalSecondRange))
                            //{
                                innerList.add("["+startIntervalFirstRange+","+ " " + endIntervalFirstRange+"]");
                                System.out.println("5Added into Inner List: " + "["+startIntervalFirstRange+","+ " " + endIntervalFirstRange+"]");
                                
                                //**REPEAT CODE //***********
                        System.out.println("start interval: " + startInterval);
                        System.out.println("end interval: " + endInterval);
                        System.out.println("start interval second range: " + startIntervalSecondRange);
                        System.out.println("end interval second range: " + endIntervalSecondRange);
                        System.out.println("start interval first range: " + startIntervalFirstRange);
                        System.out.println("end interval first range: " + endIntervalFirstRange);
                        System.out.println("Last item inner list:" + lastItemInnerList);
                        
                                mergeDirection="";
                                
                                //[1,3],  [4,7]
                              //                               7                                       3                                      7                                        4                                                7
                                if (Integer.valueOf(endIntervalSecondRange)>=Integer.valueOf(endIntervalFirstRange)  && (Integer.valueOf(endIntervalSecondRange)!=Integer.valueOf(startIntervalSecondRange)) && Integer.valueOf(endIntervalSecondRange)>Integer.valueOf(startIntervalFirstRange) &&(Integer.valueOf(endIntervalFirstRange)>=Integer.valueOf(startIntervalSecondRange)))  
                                {
                                    mergeDirection="A";
                                
                                    if (innerList.size()>0)
                                    {
                                        System.out.println("23Removed last item from innerList: " + innerList.get(innerList.size()-1));
                                        innerList.remove(innerList.size()-1);
                                    }
                                }
                                if (Integer.valueOf(endIntervalSecondRange)<=Integer.valueOf(endIntervalFirstRange)&& (endIntervalSecondRange!=startIntervalSecondRange) && Integer.valueOf(endIntervalSecondRange)<Integer.valueOf(startIntervalFirstRange) && Integer.valueOf(endIntervalFirstRange)>=Integer.valueOf(startIntervalSecondRange))
                                {
                                    mergeDirection="D";
                                
                                    if (innerList.size()>0)
                                    {
                                        System.out.println("24Removed last item from innerList: " + innerList.get(innerList.size()-1));
                                        innerList.remove(innerList.size()-1);
                                    }
                                }
                                
                                if ((Integer.valueOf(endIntervalSecondRange)==Integer.valueOf(startIntervalSecondRange)) &&   Integer.valueOf(endIntervalFirstRange)==Integer.valueOf(startIntervalFirstRange) && (Integer.valueOf(startIntervalFirstRange)==Integer.valueOf(startIntervalSecondRange)))
                                {
                                    mergeDirection="S";
                                    inc++;
                                
                                    if (innerList.size()>0)
                                    {
                                        System.out.println("24Removed last item from innerList: " + innerList.get(innerList.size()-1));
                        
                                        innerList.remove(innerList.size()-1);
                                    }
                                }
                                
                                if (Integer.valueOf(startIntervalSecondRange)==Integer.valueOf(endIntervalFirstRange))
                                {
                                    System.out.println("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
                                    startIntervalSecondRange=startIntervalFirstRange;
                                }
                            
                                innerList.add("["+startIntervalSecondRange+","+ " " + endIntervalSecondRange+"]"+mergeDirection);
                                System.out.println("6Added into Inner List: " + "["+startIntervalSecondRange+","+ " " + endIntervalSecondRange+"]"+mergeDirection);
                            
                                System.out.println("*****THE INNERLIST: " + innerList);
                                newInterval = "["+startIntervalSecondRange+","+ " " + endIntervalSecondRange+"]";
                                
                                System.out.println("**********************************");
                                //startInterval=startIntervalFirstRange;
                            
                            //} //end if
                        } //else statement
                    }  //if counter==2
                } //if counter<=2
            }//end for object
        }  //end for
        
        outerList.add(innerList);
        
        return outerList;
    }
}