import java.util.*;

public class Solution 
{
    public static void main (String[] args)
    {
        //************ALL DOCUMENTED TEST CASES**********
        //Ascending
        //float[] nums = new float[]{0f,2f,3f,4f,6f,8f,9f};   //Test case 1    PASS             
        //float[] nums = new float[]{-1f};   //Test case 2             PASS             
        //float[] nums = new float[]{0f};   //Test case 3       PASS                    
        //float[] nums = new float[]{0,1f,2,4f,5,7f};   //Test case 4    PASS            
        
        //Descending
        //float[] nums = float int[]{9f,8f,6f,4f,3f,2f,0f};    PASS            
        //float[] nums = new float[]{-1f};                PASS             
        //float[] nums = new float[]{0f};          PASS                    
        //float[] nums = new float[]{7f,5f,4f,2f,1f,0f};      PASS 
        
        //For some reason, no test cases above went through junction 8. All others are valid.
        //So these were new devised cases.....
        //float[] nums = new float[]{0f,1f,2f,4f,5f,7f,8f,10f,14f};   //Test case 4    PASS            
        //float[] nums = new float[]{0f,2f,4f,5f,7f,8f,10f,14f,17f,19f,23f,24f,25f,26f,35f,42f,43f,44f};  PASS     
        //float[] nums = new float[]{5f,4f,3f,4f,5f,7f,6f,10f,14f,17f,19f,23f,24f,25f,26f,35f,42f,47f,60f,61f};  PASS
        //float[] nums = new float[]{7f,6f,9f,3f,5f,8f};
        
        //Merging both ascending and descending code
        //float[] nums = new float[]{5f,4f,3f,4f,5f,6f,8f,8f};   PASS
        //float[] nums = new float[]{5f,4f,3f,4f,5f,7f,6f,5f,10f,14f,17f,19f,23f,24f,25f,26f,35f,34f,33f,47f};  PASS
        
        //float[] nums = new float[]{5f,6f,7f,6f,5f,9f,10f,11f,44f,45f,46f,47f,46f,45f,44f,43f,25f,24f,24f,23f,23f,22f};  //using ascending, descending and non-changing....PASS
        
        //float[] nums = new float[]{5f,9f,13f,2f,3f,4f,3f,1f,2f,3f,4f,5f,6f,22f,66f,65f,65f,64f,63f,90f,89f,60f}; //using standalone numbers in between and also ascending/descending...PASS
        //float[] nums = new float[]{1.5f,1.9f,  1.13f,  1.2f, 1.3f, 1.4f, 1.5f, 1.3f,  1.1f,  1.2f};
        
        //float[] nums = new float[]{1.5f,1.9f,  1.13f,  1.2f, 1.1f, 1.4f, 1.5f, 1.3f,  1.1f,  1.2f};
        
        //float[] nums = new float[]{2.0f,4.0f,2.0f,1.2f,1.3f,1.4f,1.3f,1.1f,1.2f,1.3f,1.4f,1.5f,1.6f,1.22f,1.66f,1.65f,1.65f,1.64f,1.63f,1.90f,1.89f,1.60f}; 
        
        //repeat numbers
        //float[] nums = new float[]{2,2,2,4,4,1,1,9,9};  PASS
        
        
        float[] nums = {
        //4.9f, 4.8f, 4.7f, 4.6f, 4.7f, 4.8f, 4.9f, 5.0f, 48.5f, 91.7f  //in test documentation,  used to test the transition 4.6
        //4.9f, 4.8f, 4.7f, 4.5f, 4.6f, 4.7f, 4.9f, 5.0f, 48.5f, 91.7f  //in test documentation , used to test 4.5f standalone merging upwards into ascending
        //0.9f, 0.8f, 0.7f, 0.6f, 0.7f, 0.8f, 0.9f, 5.0f   //test case in documentation where I resolved end of range with standalone....
        //86.0f,77.7f, 77.8f, 77.9f, 78.0f, 78.1f,78.0f, 77.9f, 77.8f, 77.7f, 25.3f, 72.8f, 42.5f   //this will be section of the ChatGPT data in order to ensure I can resolve issues quicker
        //25.3f, 72.8f,42.5f, 74.5f, 74.4f, 74.3f, 74.2f, 74.1f, 74.2f, 74.3f, 74.4f,74.5f   //this will be section of the ChatGPT data in order to ensure I can resolve issues quicker
        //47.3f, 47.2f, 47.3f, 47.4f,47.5f  //issues encountered at end of the chatGPT array. it did not merge last two items.
        
        //47.4f, 47.3f,47.4f   //realised at end of the documentation, that this is failing...
        //47.3f, 47.4f,47.3f   // NEED TO FIX THIS ALSO, resolved as part of the above one...
        //47.4f, 47.3f,47.5f  //NEED TO FIX THIS ALSO
        //47.3f, 47.4f,47.5f  //late fixes in code
        //47.3f, 47.2f,47.3f,47.4f  //late fixes in code 
        //47.4f,47.3f,47.2f,47.4f  //late fixes in code
        //47.3f,47.2f,47.3f,47.4f,47.5f  //late fixes in code
        //47.3f,47.2f,47.3f //late fixes in code
        //47.2f,47.3f,47.2f //late fixes in code
        //47.2f,47.3f,47.2f,47.1f //late fixes in code
        
        //this is second chatGPT extract
        //30032025/SummaryRange/5/4/ChatGPTgeneratedNumbersBetterDataSet.txt
        75.0f, 75.0f, 95.6f, 95.7f, 95.8f, 95.9f, 96.0f, 96.1f, 40.1f, 40.1f,35.1f, 35.2f, 35.3f, 35.2f, 35.1f, 85.6f, 85.5f, 85.4f, 85.3f, 85.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 63.5f, 14.9f, 14.9f, 48.6f, 48.5f, 48.4f, 48.3f, 48.2f, 48.3f, 48.4f, 48.5f, 48.6f, 65.2f, 82.1f, 82.2f, 82.3f, 82.4f, 82.5f, 82.4f, 82.3f, 82.2f, 82.1f, 28.9f, 28.8f, 28.7f, 28.6f, 28.5f, 28.4f, 28.3f, 28.2f, 28.1f, 28.0f, 39.0f, 33.6f, 33.7f, 33.8f, 33.9f, 34.0f, 34.1f, 34.2f, 34.3f, 75.9f, 75.9f, 54.3f, 54.2f, 54.1f, 54.0f, 53.9f, 54.0f, 54.1f, 54.2f, 54.3f, 11.5f, 91.4f, 91.5f, 91.6f, 91.7f, 91.8f, 91.7f, 91.6f, 91.5f, 91.4f, 66.8f, 66.9f, 67.0f, 67.1f, 67.2f, 67.3f,  7.7f,  7.7f, 49.6f, 49.6f, 49.6f, 57.7f, 57.8f, 57.9f, 58.0f, 58.1f, 58.0f, 57.9f, 57.8f, 57.7f, 24.2f, 70.5f, 70.4f, 70.3f, 70.2f, 70.1f, 70.0f, 69.9f, 69.8f, 69.7f, 92.2f, 31.3f, 31.4f, 31.5f, 31.6f, 31.7f, 31.8f, 31.7f, 31.6f, 31.5f, 31.4f, 13.3f, 13.3f, 86.4f, 86.3f, 86.2f, 86.1f, 86.0f, 85.9f, 85.8f, 85.7f, 45.0f, 45.1f, 45.2f, 45.3f, 45.4f, 45.5f, 45.4f, 45.3f, 45.2f, 45.1f, 22.2f, 22.2f, 22.2f, 99.0f, 98.9f, 98.8f, 98.7f, 98.6f, 98.5f, 98.6f, 98.7f, 98.8f, 98.9f, 99.0f, 12.8f, 12.9f, 13.0f, 13.1f, 13.2f, 13.3f, 13.4f, 13.5f, 13.6f, 13.7f, 55.4f, 55.5f, 55.6f, 55.7f, 55.8f, 55.9f, 55.8f, 55.7f, 55.6f, 55.5f, 40.2f, 40.2f, 40.2f, 83.0f, 82.9f, 82.8f, 82.7f, 82.6f, 82.5f, 82.4f, 82.5f, 82.6f, 82.7f, 82.8f,30.8f, 30.9f, 31.0f, 31.1f, 31.2f, 31.1f, 31.0f, 30.9f, 30.8f, 18.5f,62.9f, 63.0f, 63.1f, 63.2f, 63.3f, 63.4f, 63.3f, 63.2f, 63.1f, 63.0f,41.2f, 41.1f, 41.0f, 40.9f, 40.8f, 40.7f, 40.6f, 40.5f, 40.4f, 40.3f,18.7f, 18.8f, 18.9f, 18.8f, 18.7f, 60.7f, 60.6f, 60.5f, 60.4f, 60.3f,60.4f, 60.5f, 60.6f, 60.7f, 71.3f, 71.4f, 71.5f, 71.6f, 71.7f, 71.6f,71.5f, 71.4f, 71.3f, 55.1f
        };
        //40.1f, 40.1f, 35.1f, 35.2f, 35.3f, 35.2f, 35.1f, 85.6f, 85.5f, 85.4f, 85.3f, 85.2f,19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 63.5f  };
       
        System.out.println(summaryRanges(nums));
    }
    
    public static List<String> summaryRanges(float[] nums) 
    {
        final float epsilon = 0.0005f;
        
        boolean combineMerge=false;
        
        //I have chosen to start with a true value since I can forsee violation due to default being false
        boolean hasNotWrittenLastNumber=true;
        
        boolean isFirstOccurenceAscendingChain=false;
        boolean isFirstOccurenceAscendingChainNoTransition =false;
        
        List<String> sm = new ArrayList<>();
        int counter = 0;
        String start="";
        String end="";
        String temp="";
        String backupStart="";
        boolean hasTransition=false;
        String transitionNumber="";
        float difference=0.1f;

        if (nums.length==1)
        {
            sm.add(String.valueOf(nums[0]));
            System.out.println("1Writing Standalone: " + nums[0]);
            return sm;
        }

        for (int k=0; k<nums.length-1;k++)
        {
            if (k==0)
            {
                start=String.valueOf(nums[k]);
            }
            
            if (nums[k]!=nums[k+1])
            {
            
            System.out.println("CHECKING: " + nums[k] + " with " + nums[k+1]);
            System.out.println(nums[k]+difference);   //5.0
            System.out.println(nums[k]-difference);   //4.8
            
            
            
            //Math.abs(current - (prev + difference ))< epsilon
            //we need to understand which is current, prev
            //if nums[k] is current
            //Math.abs(4.9 - (4.8 + 0.1)) < 0.00005
            //if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
            
            if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
            //if ((nums[k]+difference)==(nums[k+1]))
            {
                if (counter==0)
                {
                    backupStart=String.valueOf(nums[k]);
                }
                
                if (counter==0 && (k==nums.length-2))
                {
                    start=String.valueOf(nums[k]);
                    end = String.valueOf(nums[k+1]);
                    sm.add(start+"->"+end);
                    System.out.println("5Writing range: " + start + "-> " + end); 
                    isFirstOccurenceAscendingChain=false;
                    isFirstOccurenceAscendingChainNoTransition=false;
                    break;
                }
                
                if (counter!=0 && (k==nums.length-2))
                {
                    end=String.valueOf(nums[k+1]);
                    sm.add(start +"->"+end);
                    System.out.println("6Writing range: " + start + "-> " + end);
                    isFirstOccurenceAscendingChain=false;
                    isFirstOccurenceAscendingChainNoTransition=false;
                }

                if (counter==0)
                {
                     if (isFirstOccurenceAscendingChainNoTransition || isFirstOccurenceAscendingChain)
                    {
                        end=String.valueOf(nums[k]);
                        sm.add(start+"->"+end);
                        System.out.println("28Writing range: " + start + "-> " + end);
                        isFirstOccurenceAscendingChain=false;
                        isFirstOccurenceAscendingChainNoTransition=false;
                    }
                    
                    
                    start=String.valueOf(nums[k]);
                    System.out.println("Establishing start: " + start);
                    
                   
                    
                    
                    
                    if (k==nums.length-1)
                    {
                        System.out.println("2Writing Standalone: " + start);
                        sm.add(start);
                    }
                }
                counter++; 
            }
            else
            {
                if (k==nums.length-2)
                {
                    if (temp!="")
                    {
                        sm.add(temp);
                        System.out.println("9Writing range: " + temp);
                        isFirstOccurenceAscendingChain=false;
                        isFirstOccurenceAscendingChainNoTransition=false;
                    }
                    
                    if (counter==0)
                    {
                             //descending
                             //checking 47.3  with 47.4 (this is not descending)
                             //so it enters the else
                             
                             //descending
                        if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                        //if ((nums[k]-difference)==(nums[k+1]))
                        {
                            start=String.valueOf(nums[k]);
                            end = String.valueOf(nums[k+1]);
                            sm.add(start+"->"+end);
                            System.out.println("7Writing range: " + start + "-> " + end);
                            isFirstOccurenceAscendingChain=false;
                            isFirstOccurenceAscendingChainNoTransition=false;
                        }
                        else  //it is here due to ascending   we know in   47.3,  (47.4),  47.5 this is scenario
                        {
                            end = String.valueOf(nums[k]);   //it sets 47.3 as the end
                            
                            if (isFirstOccurenceAscendingChainNoTransition || isFirstOccurenceAscendingChain)
                            {
                                //shows next is ascending
                                            //72.8       //42.5
                                //we wrote this section of code when 
                                if (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                                {
                                    end=String.valueOf(nums[k+1]);
                                      sm.add(start+"->"+end);
                                      System.out.println("35Writing range: " + start + "-> " + end); 
                                      hasNotWrittenLastNumber=false;
                                      isFirstOccurenceAscendingChain=false;
                                      isFirstOccurenceAscendingChainNoTransition=false;
                                }
                                else
                                {
                                    end=String.valueOf(nums[k]);
                                    sm.add(start+"->"+end);
                                    System.out.println("27Writing range: " + start + "-> " + end);
                                    isFirstOccurenceAscendingChain=false;
                                    isFirstOccurenceAscendingChainNoTransition=false;
                                    //sm.add(String.valueOf(nums[k+1]));
                                }
                            }     //it is here because it has not performed boolean due to extended ascending or descending
                                  //but it has to 
                                  //my logic suggests that it can be merged with nums[k+1]
                                  //and the area of code where it performs 4Writing standalone can be modified
                                  //I will set another boolean in code below so that it ensures that 47.5 is entered again...
                            else
                            {
                            
                            if (temp=="")
                            {
                                //if prev number is less than nums k
                                if (Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)
                                {
                                   start=String.valueOf(nums[k-1]);
                                   end=String.valueOf(nums[k+1]);
                                   sm.add(start+"->"+end);
                                    System.out.println("9876Writing range: " + start + "-> " + end);
                                    isFirstOccurenceAscendingChain=false;
                                    isFirstOccurenceAscendingChainNoTransition=false;
                                    //combineMerge=true;
                                }
                                else
                                {
                                    
                                
                                //LATE CODE REMOVAL
                                //System.out.println("3Writing Standalone: " + end);
                                //sm.add(end);
                                end=String.valueOf(nums[k+1]);
                                start=String.valueOf(nums[k]);
                                sm.add(start+"->"+end);
                                System.out.println("98Writing range: " + start + "-> " + end);
                                isFirstOccurenceAscendingChain=false;
                                isFirstOccurenceAscendingChainNoTransition=false;
                                
                                //At this moment in time,  I am not sure when to set the variable back to false!
                                }
                                combineMerge=true;
                            }
                            }
                            
                            //it has written last number as part of the chain
                            //it has set the value to false above.......
                            //74.1f, 74.2f, 74.3f, 74.4f,(74.5f)
                            //so we enter here if the condition is true only......
                            //it is very difficult to give this a better name given naming convention boolean is or has.....
                            
                            if (hasNotWrittenLastNumber && !combineMerge)
                            {
                                start=String.valueOf(nums[k+1]);
                                System.out.println("4Writing Standalone: " + start);
                                sm.add(start);
                                hasNotWrittenLastNumber=false;
                            }
                            
                        }
                    }
                    else   //we are here because counter!=0  and   k==nums.length-2
                            //with this data....   47.4f, (47.3f),47.4f,  it relates to 47.3f
                            //I have checked chatGPT and my code has not entered this section
                            
                            
                            
                    {
                        System.out.println("MUST BE HERE SO TRANSITION PART NOT PRESENT");
                        System.out.println("HAT IS START: " + start);
                        end=String.valueOf(nums[k]);
                        sm.add(start+"->"+end);
                        System.out.println("3Writing range: " + start + "-> " + end);
                        isFirstOccurenceAscendingChain=false;
                        isFirstOccurenceAscendingChainNoTransition=false;
                        
                        //here we know there is only one value after current one... we need to check if it is descending or ascending
                        //and then formulate the closure
                        //
                        
                        //it needs to pass one of these scenarios, no effect on start or end
                        //checking 47.3 with 47.4 
                                      //descending                                                //ascending
                        if ( (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)   ||   
                              (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
                        {
                            start=String.valueOf(nums[k]);
                            end=String.valueOf(nums[k+1]);
                            sm.add(start+"->"+end);
                            System.out.println("49Writing range: " + start + "-> " + end);
                            isFirstOccurenceAscendingChain=false;
                            isFirstOccurenceAscendingChainNoTransition=false;
                            
                        }
                        else
                        {
                            start=String.valueOf(nums[k+1]);
                            sm.add(start);
                            System.out.println("599Writing standalone: " + start);
                        }
                        
                        
                        //NO IDEA WHy THIS WAS INCLUDED
                        //sm.add(String.valueOf(nums[k+1]));
                    }
                }
                else       //   (k!=nums.length-2)
                {
                    //descending
                    if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                    //if ((nums[k]-difference)==(nums[k+1]))
                    {
                        end=String.valueOf(nums[k+1]);
                    }
                    else
                    {
                        end=String.valueOf(nums[k]);
                    }
                    if (counter==0)
                    {
                        if(k==0)
                        {
                            //descending
                            //I am extremely hesitant to start performing and ascending check here
                            //since I have no idea if my code has entered here before due to lack of screen outputs
                            //we know for an array such as  (47.3), 47.4 and 47.3, it will not enter here on the 1st element
                            if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                            //if ((nums[k]-difference)==(nums[k+1]))
                            {
                                start=String.valueOf(nums[k]);
                                counter++;
                            }
                            else   //since confident code has not entered here, I will place logic here
                            {
                                //ascending
                                if (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                                {
                                    start=String.valueOf(nums[k]);
                                    end=String.valueOf(nums[k+1]);
                                    sm.add(start+"->"+end);
                                    System.out.println("58Writing range: " + start + "-> " + end);
                                    isFirstOccurenceAscendingChain=false;
                                    isFirstOccurenceAscendingChainNoTransition=false;
                                }
                                else
                                {
                                System.out.println("5Writing standalone: " + start);
                                sm.add(start);
                                }
                            }
                        }
                        else
                        {
                            if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                            //if ((nums[k]-difference)==(nums[k+1]))
                            {
                                if (temp=="")
                                {
                                    if (Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)
                                    //if ((nums[k-1]-difference)==(nums[k]))
                                    {
                                        backupStart=String.valueOf(nums[k-1]);
                                    }
                                    else
                                    {
                                        backupStart=String.valueOf(nums[k]);
                                    }
                                    
                                    temp=backupStart+"->"+end;
                                    hasTransition=false;
                                }
                                else
                                {
                                    end=String.valueOf(nums[k+1]);
                                    temp=backupStart+"->"+end;
                                    hasTransition=false;
                                }
                                System.out.println("8Storing range: " + temp);
                            }
                            else
                            {
                                if (temp!="")
                                {
                                    sm.add(temp);
                                    System.out.println("8Writing range: " + temp);
                                    temp="";
                                    backupStart="";
                                    isFirstOccurenceAscendingChain=false;
                                    isFirstOccurenceAscendingChainNoTransition=false;
                                }
                                
                                
                                else
                                {
                                    //to ensure a standalone does not enter the else loop, the first part determines relationship
                                    //with nums[k-1] but we need to forge connection with nums[k+1]
                                    //ie if nums[k] + difference is  within tolerance of nums[k+1]  ie still ascending
                                    
                                    
                                  //                4.5       4.7       //suggesting ascending, not applicable 
                                    if ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)
                                    
                                //              4.6                        4.5       //this is applicable
                                    ||   (Math.abs(nums[k+1] - (nums[k] + difference)) <epsilon))
                                    //if ((nums[k-1]-difference)==(nums[k]))
                                    {
                                        
                                        //ultimately we know that sequence is 4.7,   (4.5),    4.6
                                        //so what makes it different to  4.7,    (4.6), 4.7, 4.8....
                                        
                                                                                //we are still interested in the start only once, but this time it would be
                                        //nums[k]
                                        //we know the below loop wont allow entry due to 4.7,   (4.5),    4.6
                                        //so I can lessen the scope first to check if nums[k+1]+diff >=nums[k]
                                        //to establish start once....
                                        //and then if it goes into the wider scope for
                                        //4.7,    (4.6), 4.7, 4.8....  it would get nums[k-1] to represent the transition...
                                        
                                        //we know it would enter here for cases such as  4.6->4.7
                                        
                                        //String backupEnd = end;            //this would be 4.6 value before
                                        end = String.valueOf(nums[k]);
                                        
                                        //since for ascending, we are getting entries such as
                                        //4.6->4.7, 4.7->4.8, 4.8->4.9, 4.9->5.0
                                        //we need to merge summary range together again
                                        
                                         //4.9f, 4.8f, 4.7f, 4.6f,        4.7f, 4.8f, 4.9f, 5.0f, 48.5f, 91.7f
                                        
                                        System.out.println("This is start: " + start);
                                        
                                        //here we know we are in ascending area....
                                        //so we need to check using epsilon if the prev is less than current
                                        //within margin of error 
                                        
                                        //this logic suggests previous number is lower since addding difference
                                        //it also has to ensure the front is increasing by difference, in which case we have to subtract difference from nums[k+1]
                                        //also need to find a way of not keep obtaining the start...
                                        //it would only get the start on the first instance of the below if loop
                                        //for instance we want start to remain as 4.6f and not be adjusted everytime nums[k] increases
                                        
                                        //4.6f,        4.7f, 4.8f, 4.9f, 5.0f,
                                        
                                                   
                                                  // 4.5                 4.6       narrow scope
                                        
                                        //ascending going forward, does not consider number before          
                                        if  (Math.abs(nums[k] - (nums[k+1] - difference))<epsilon)
                                        {
                                            if (!isFirstOccurenceAscendingChainNoTransition)
                                            {
                                                start=String.valueOf(nums[k]);  //4.5
                                                System.out.println("1BUT ACKNOWLEDGED START: " + start);
                                                
                                                //need to lock this loop until else has reached
                                                isFirstOccurenceAscendingChainNoTransition=true;
                                                System.out.println("********isFirstOccurenceAscendingChainNoTransition*****: " + "set to true");
                                            }
                                        
                                        
                                        //wider scope
                                        //this is basically showing that ascending sequence.....
                                        //we know it breaks away from this when the next number is out of consecutive sequence...
                                        //but we need to include logic if the ascending transitions to descending...
                                        //otherwise it will fail circumstances such as since it has identified break of ascending at 78.0f
                                        //unfortunately it can not go into else since its not part of the same block area...
                                        
                                        
                                        //77.7f, 77.8f, 77.9f, 78.0f, 78.1f, (78.0f), 77.9f, 77.8f, 77.7f,     

                                        
                                        //ascending going forward
                                        if ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)
                                        
                                        //descending going back
                                        &&   (Math.abs(nums[k] - (nums[k+1] - difference))<epsilon))
                                        {
                                            System.out.println("DO NOTHING******************");
                                            
                                            if (!isFirstOccurenceAscendingChain)
                                            {
                                                start=String.valueOf(nums[k-1]);  //4.6
                                                System.out.println("2BUT ACKNOWLEDGED START: " + start);
                                                
                                                //need to lock this loop until else has reached
                                                isFirstOccurenceAscendingChain=true;
                                                System.out.println("********isFirstOccurenceAscendingChain*****: " + "set to true");
                                            }
                                        }
                                    }
                                        
                                        else  // its here because sequence is not ascending  (3.6 with 40.0)
                                        {
                                            System.out.println("BREAKING FLOW--------------------------------------------------------");
                                            isFirstOccurenceAscendingChain=false;
                                            isFirstOccurenceAscendingChainNoTransition=false;
                                            System.out.println("**************************");
                                            sm.add(start+"->"+end);
                                            System.out.println("11Writing range: " + start+"->"+end);
                                            isFirstOccurenceAscendingChain=false;
                                            isFirstOccurenceAscendingChainNoTransition=false;
                                        }
                                    }  //else opposing 8write rangey
                                    
                                    
                                    else
                                    {
                                        start = String.valueOf(nums[k]);
                                        sm.add(start);
                                        System.out.println("6Writing Standalone: " + start);
                                        isFirstOccurenceAscendingChain=false;
                                        isFirstOccurenceAscendingChainNoTransition=false;
                                    }
                                }  //wide else
                            }
                        }
                    }
                    else
                    {
                        if ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)  && (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
                        //if ((nums[k-1]+difference)==(nums[k]) &&  (nums[k])==(nums[k+1])+difference)
                        {
                            end=String.valueOf(nums[k]);
                            sm.add(backupStart+"->"+end);
                            System.out.println("10Writing range: " + backupStart+"->"+end);
                            hasTransition=true;
                            transitionNumber=String.valueOf(nums[k]);
                            isFirstOccurenceAscendingChain=false;
                            isFirstOccurenceAscendingChainNoTransition=false;
                        }
                        if (!hasTransition)
                        {
                            if (temp!="")
                            {
                                end=String.valueOf(nums[k+1]);
                                sm.add(start+"->"+end);
                            }
                            else
                            {
                                System.out.println("2Writing range: " + start + "-> " + end); 
                                sm.add(start+"->"+end);
                                isFirstOccurenceAscendingChain=false;
                                isFirstOccurenceAscendingChainNoTransition=false;
                            }
                        }
                        counter=0;
                        temp="";
                        backupStart="";
                        hasTransition=false;
                    }
                }
            }
        }
    }
        return sm;
    }
}