// Please see this additional function provided by chatGPT. It is turned off by default
//It provides true behaviour for making ΔD mismatches possible in a controlled, explainable way.
// Default is false to preserve your legacy behavior.
//static boolean ENABLE_DESCENDING_CONFIRMATION_SKIP = false;


import java.util.*;

public class Solution 
{
    static int tickerCounterOnPreviousRange;
    static int transitionEvents;
    static String previousOutcome="";
    static List<String> sm = new ArrayList<>();
    static String standaloneTemp="";
    static final float epsilon = 0.0005f;
    static boolean hasAdjust=false;
    static int tickerCounter=0;
    static int ascendingChainsComplete;
    static int descendingChainsComplete;
    static int standaloneCount;
    static String ticker="";

    // --------------------CHATGPT---------------------
    // Latest "shape-only" ticker result built in summaryRanges(), for comparison in main.
    static TickerResult lastChatgptTickerV2;

    // --------------------CHATGPT  ΔD---------------------
    // Optional: enable a symmetrical "confirmation skip" for DESCENDING runs in the Amit (reset/magnitude) path.
    // When enabled, the first D step after a boundary/transition can be treated as confirmation (not counted),
    // making ΔD mismatches possible in a controlled, explainable way.
    // Default is false to preserve your legacy behavior.
    static boolean ENABLE_DESCENDING_CONFIRMATION_SKIP = false;
    // --------------------END CHATGPT  ΔD---------------------

    // -----------------------END CHATGPT-------------------

    static int ascendingCounter;
    static int descendingCounter;
    static boolean isStandalone=false;
    static float difference=0.1f;
    static boolean hasStandaloneAfter=true;
    static String potentialfurtherAscendingBeyondThisStart="";
    static String potentialfurtherAscendingBeyondThisEnd="";
    static boolean hasTransition=false;
    
    static int counter = 0;
    
      //************ALL DOCUMENTED TEST CASES**********
    //Ascending
    //static float[] nums = new float[]{0f,2f,3f,4f,6f,8f,9f};   //Test case 1    PASS             
    //static float[] nums = new float[]{-1f};   //Test case 2             PASS             
    //static float[] nums = new float[]{0f};   //Test case 3       PASS                    
    //static float[] nums = new float[]{0,1f,2,4f,5,7f};   //Test case 4    PASS               
        
    //Descending
    //static float[] nums = new float[]{9f,8f,6f,4f,3f,2f,0f};    //PASS            
    //static float[] nums = new float[]{-1f};                //PASS             
    //static float[] nums = new float[]{0f};          //PASS                    
    //static 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.....
    //static float[] nums = new float[]{0f,1f,2f,4f,5f,7f,8f,10f,14f};   //Test case 4    PASS            
    //static float[] nums = new float[]{0f,2f,4f,5f,7f,8f,10f,14f,17f,19f,23f,24f,25f,26f,35f,42f,43f,44f};  //PASS     
    //static 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
    //static float[] nums = new float[]{7f,6f,9f,3f,5f,8f};
        
    //Merging both ascending and descending code
    //static float[] nums = new float[]{5f,4f,3f,4f,5f,6f,8f,8f};   //PASS
    //static 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
        
    //static 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
        
    //static 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
        
    //static float[] nums = new float[]{1.5f,1.9f,  1.13f,  1.2f, 1.3f, 1.4f, 1.5f, 1.3f,  1.1f,  1.2f}; //all ok, ticker=ok
    //static float[] nums = new float[]{1.5f,1.9f,  1.13f,  1.2f, 1.1f, 1.4f, 1.5f, 1.3f,  1.1f,  1.2f}; //all ok, ticker=ok
        
    //ok, ticker= ok
    //static 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
    //static float[] nums = new float[]{2,2,2,4,4,1,1,9,9};  //PASS

    static 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   ok, counter=ok
        //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  ok, ticker=ok
        //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....  ok, counter=ok
        //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, ok, ticker=ok
        //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, ok, ticker=ok
        //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.  ok, ticker=ok
        
        //47.4f, 47.3f,47.4f   //realised at end of the documentation, that this is failing...  ok, ticker=ok
        //47.3f, 47.4f,47.3f   // NEED TO FIX THIS ALSO, resolved as part of the above one...  ok, ticker=ok
        //47.4f, 47.3f,47.2f,47.5f  //NEED TO FIX THIS ALSO  ok, ticker=ok
        //47.3f, 47.4f,47.5f  //late fixes in code   -  FAIL   (this is straight forward ascending)  -  FAIL************  ok, ticker=ok
        //47.3f, 47.2f,47.3f,47.4f  //late fixes in code   ok, ticker=ok
        //47.4f,47.3f,47.2f,47.4f  //late fixes in code   ok, ticker=ok
        //47.3f,47.2f,47.3f,47.4f,47.5f  //late fixes in code  ok, ticker=ok
        //47.3f,47.2f,47.3f //late fixes in code  ok, ticker=ok
        //47.2f,47.3f,47.2f //late fixes in code  ok, ticker=ok
        //47.2f,47.3f,47.2f,47.1f //late fixes in code
        
        //this is first chatGPT extract
        //30032025/SummaryRange/5/4/ChatGPTgeneratedNumbers.txt
        //4.9f, 4.8f, 4.7f, 4.6f, 4.7f, 4.8f, 4.9f, 5.0f, 48.5f, 91.7f, 82.9f, 57.6f, 57.5f, 57.4f, 57.3f, 57.2f, 57.3f, 57.4f, 57.5f, 57.6f, 26.1f, 25.4f, 21.2f, 83.5f, 56.3f, 56.2f, 56.1f, 56.0f, 55.9f, 55.8f, 55.7f, 55.6f, 13.9f, 35.7f, 54.8f, 54.7f, 54.6f, 54.5f, 54.6f, 54.7f, 54.8f, 54.9f, 49.9f,  9.6f, 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, 74.5f, 74.4f, 74.3f, 74.2f, 74.1f, 74.2f, 74.3f, 74.4f, 74.5f, 90.6f, 30.0f, 66.5f, 11.2f, 64.2f, 64.3f, 64.4f, 64.5f, 64.6f, 64.5f, 64.4f, 64.3f, 64.2f, 18.8f, 49.3f, 60.3f, 51.1f, 52.5f, 52.4f, 52.3f, 52.2f, 52.1f, 52.0f, 51.9f, 51.8f,  1.8f, 70.5f, 69.2f, 79.8f, 86.7f, 86.6f, 86.5f, 86.4f, 86.3f, 86.4f, 86.5f, 86.6f, 86.7f, 17.9f, 80.8f, 23.9f, 89.6f, 36.0f, 35.9f, 35.8f, 35.7f, 35.6f, 35.7f, 35.8f, 35.9f, 36.0f, 95.8f, 28.9f, 71.6f,  5.3f, 60.0f, 60.1f, 60.2f, 60.3f, 60.4f, 60.3f, 60.2f, 60.1f, 60.0f, 45.2f, 16.2f, 50.6f, 34.1f, 68.4f, 68.3f, 68.2f, 68.1f, 68.0f, 67.9f, 67.8f, 67.7f, 67.6f, 89.9f, 27.1f, 14.4f, 98.9f, 63.8f, 63.9f, 64.0f, 64.1f, 64.2f, 64.1f, 64.0f, 63.9f, 63.8f, 54.8f, 22.6f, 41.1f, 91.4f, 47.9f, 47.8f, 47.7f, 47.6f, 47.5f, 47.6f, 47.7f, 47.8f, 47.9f, 58.5f, 70.8f, 11.3f, 58.6f, 58.7f, 58.8f, 58.9f, 59.0f, 58.9f, 58.8f, 58.7f, 58.6f, 35.3f, 76.8f, 44.2f, 96.7f, 52.0f, 51.9f, 51.8f, 51.7f, 51.6f, 51.5f, 51.4f, 51.3f, 51.2f, 20.3f, 93.8f, 37.8f, 61.8f, 30.6f, 30.7f, 30.8f, 30.9f, 31.0f, 30.9f, 30.8f, 30.7f, 30.6f, 12.1f, 84.4f,  2.9f, 63.2f, 69.7f, 69.6f, 69.5f, 69.4f, 69.3f, 69.4f, 69.5f, 69.6f, 69.7f, 55.4f, 81.6f, 32.4f,  6.0f, 79.8f, 79.9f, 80.0f, 80.1f, 80.2f, 80.1f, 80.0f, 79.9f, 79.8f, 88.2f, 21.3f, 45.1f, 90.3f, 42.3f, 42.2f, 42.1f, 42.0f, 41.9f, 41.8f, 41.7f, 41.6f, 41.5f, 62.9f, 97.6f, 53.1f, 24.7f, 66.0f, 65.9f, 65.8f, 65.7f, 65.6f, 65.7f, 65.8f, 65.9f, 66.0f, 49.6f, 83.5f, 38.6f, 10.4f, 77.6f, 77.5f, 77.4f, 77.3f, 77.2f, 77.3f, 77.4f, 77.5f, 77.6f,  3.1f, 60.6f, 88.0f, 92.6f, 74.6f, 74.7f, 74.8f, 74.9f, 75.0f, 74.9f, 74.8f, 74.7f, 74.6f, 31.4f, 13.4f, 55.7f, 64.5f, 50.2f, 50.1f, 50.0f, 49.9f, 49.8f, 49.9f, 50.0f, 50.1f, 50.2f, 58.0f, 67.8f, 41.3f, 96.8f, 72.3f, 72.2f, 72.1f, 72.0f, 71.9f, 71.8f, 71.7f, 71.6f, 71.5f, 29.7f, 81.9f, 18.0f, 46.4f, 34.3f, 34.4f, 34.5f, 34.6f, 34.7f, 34.6f, 34.5f, 34.4f, 34.3f, 85.7f, 14.3f, 26.5f, 56.9f, 61.6f, 61.5f, 61.4f, 61.3f, 61.2f, 61.1f, 61.0f, 60.9f, 60.8f, 43.6f, 89.0f,  7.1f, 75.2f, 39.2f, 39.1f, 39.0f, 38.9f, 38.8f, 38.9f, 39.0f, 39.1f, 39.2f, 94.9f, 23.7f, 48.2f, 87.2f, 52.8f, 52.9f, 53.0f, 53.1f, 53.2f, 53.1f, 53.0f, 52.9f, 52.8f, 12.8f, 97.0f, 20.7f, 68.9f, 73.1f, 73.0f, 72.9f, 72.8f, 72.7f, 72.6f, 72.5f, 72.4f, 72.3f, 54.6f, 15.5f, 40.1f, 30.8f, 63.5f, 63.4f, 63.3f, 63.2f, 63.1f, 63.0f, 62.9f, 62.8f, 62.7f, 49.2f,  5.9f, 91.5f, 84.7f, 51.0f, 50.9f, 50.8f, 50.7f, 50.6f, 50.7f, 50.8f, 50.9f, 51.0f, 78.7f, 36.4f, 59.9f, 95.3f, 44.9f, 44.8f, 44.7f, 44.6f, 44.5f, 44.4f, 44.3f, 44.2f, 44.1f, 83.6f, 25.9f, 32.1f, 11.1f, 67.5f, 67.4f, 67.3f, 67.2f, 67.1f, 67.2f, 67.3f, 67.4f, 67.5f, 52.7f, 98.0f, 19.5f, 60.7f, 28.1f, 28.0f, 27.9f, 27.8f, 27.7f, 27.8f, 27.9f, 28.0f, 28.1f, 70.7f, 54.5f, 13.5f, 77.1f, 41.2f, 41.1f, 41.0f, 40.9f, 40.8f, 40.7f, 40.6f, 40.5f, 40.4f, 59.4f, 90.0f,  6.7f, 85.4f, 69.5f, 69.6f, 69.7f, 69.8f, 69.9f, 70.0f, 70.1f, 70.2f, 70.3f, 38.0f, 12.4f, 95.2f, 57.1f, 50.4f, 50.3f, 50.2f, 50.1f, 50.0f, 49.9f, 49.8f, 49.7f, 49.6f, 61.7f, 27.6f, 43.1f, 83.8f, 73.4f, 73.5f, 73.6f, 73.7f, 73.8f, 73.7f, 73.6f, 73.5f, 73.4f, 16.3f, 97.2f, 21.5f, 66.2f, 47.1f, 47.2f, 47.3f, 47.4f, 47.5f, 47.4f, 47.3f, 47.2f, 47.1f, 33.5f, 76.3f, 42.9f,  4.3f, 62.4f, 62.3f, 62.2f, 62.1f, 62.0f, 61.9f, 61.8f, 61.7f, 61.6f, 82.4f, 24.4f, 58.4f,  9.7f, 90.4f, 90.3f, 90.2f, 90.1f, 90.0f, 89.9f, 89.8f, 89.7f, 89.6f, 34.9f, 14.7f, 30.2f, 96.2f, 52.4f, 52.3f, 52.2f, 52.1f, 52.0f, 51.9f, 51.8f, 51.7f, 51.6f, 71.8f, 59.2f, 10.6f, 84.2f, 63.7f, 63.8f, 63.9f, 64.0f, 64.1f, 64.0f, 63.9f, 63.8f, 63.7f, 46.6f, 18.2f, 45.4f, 82.0f, 78.6f, 78.5f, 78.4f, 78.3f, 78.2f, 78.3f, 78.4f, 78.5f, 78.6f, 95.4f, 32.6f, 23.3f, 68.8f, 41.8f, 41.7f, 41.6f, 41.5f, 41.4f, 41.3f, 41.2f, 41.1f, 41.0f, 58.9f, 27.4f, 56.1f, 88.7f, 50.8f, 50.9f, 51.0f, 51.1f, 51.2f, 51.1f, 51.0f, 50.9f, 50.8f, 12.9f, 72.1f, 33.3f, 67.9f, 74.9f, 74.8f, 74.7f, 74.6f, 74.5f, 74.6f, 74.7f, 74.8f, 74.9f, 49.0f, 21.9f, 61.2f, 93.6f, 55.3f, 55.2f, 55.1f, 55.0f, 55.1f, 55.2f, 55.3f, 55.4f, 55.5f, 43.4f, 61.0f, 47.3f, 47.4f
        
        //small extract taken from second chatGPT extract.  ok, ticker=ok     ?
        //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    
   
        //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    //************************FAIL  //ok, ticker=ok
        
        //this is second chatGPT extract
        //30032025/SummaryRange/5/4/ChatGPTgeneratedNumbersBetterDataSet.txt    ok, ticker=ok
        //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
        
        //part of extract  ok, ticker=ok
        //85.3f, 85.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 63.5f, 14.9f, 14.9f
        
        //ok, ticker=fail  DD(*A*-D)
        //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
       
       
       //*********INVESTIGATING THOROUHGLY FAILED A TICKER*******************************************************
       //See last documentation
       //ok, ticker=fail  DA(*A*-D)  *
       //35.3f, 35.2f, 35.1f, 85.6f, 85.7f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
       //ok, ticker=fail  SA(*A*-D)  *
       //35.1f,85.6f, 85.7f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
       //ok, ticker=fail  AA(*A*-D)  *
      //35.1f,35.2f, 85.6f, 85.7f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
      
      //ok, ticker=fail  DD(*A*-D)  *
       //35.1f,35.0f,55.2f,55.1f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
       //ok, ticker=ok  SS(*A*-D)  *
       //35.1f,55.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
       //ok, ticker=ok  AS(*A*-D) *
       //35.1f,35.2f, 55.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
       //ok, ticker=ok  DS(*A*-D)  *
       //35.2f,35.1f, 55.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.
       
       //ok, ticker=ok  SS(*A*-D)  *
       //35.2f,35.6f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
       
       //ok, ticker=fail  AD(*A*-D)
       //35.1f,35.2f, 55.2f,55.1f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
        //ok, ticker=ok  SD(*A*-D)
       //35.1f,55.2f,55.1f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
       
       //ok, ticker=fail  A-D(*A*-D)
       //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
       //ok, ticker=fail  D-A(*A*-D)
       //19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.3f, 19.4f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
       
        //ok, ticker=ok  A-D(*D*-A)
       //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 19.6f, 19.5f, 19.4f, 19.3f, 19.4f, 19.5f, 19.6f
      
       //ok, ticker=ok  D-A(*D*-A)
       //19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.3f, 19.4f, 19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.3f, 19.4f
       
       
       //THESE ARE NO LONGER ISSUES
       //ok, ticker=ok  (A-D)*A
       //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f,56.7f,56.8f,56.9f
       
       //ok, ticker=ok  (A-D)*D
       //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f,56.7f,56.6f,56.5f
       //***********************************************************************************************************
       
        //***THESE ARE EXTRACTS FROM CHATGPT second extract.... *****
        //Trying to understand why failing after changes in code.. It now passes
        //75.9f, 75.9f, 54.3f, 54.2f, 54.1f, 54.0f, 53.9f, 54.0f, 54.1f, 54.2f, 54.3f, 11.5f  //(RESOLVED)  ok, ticker=ok
        //I am not sure where (53.9->54.0) has arisen from..
        //I will quickly investigate
        //[33.9->34.3, 75.9, 54.3->53.9, (53.9->54.0), 53.9->54.3, 11.5, 91.4->91.8]
       
        //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   //ok, ticker=ok
       
        //focussing on 2-3 runs of ascending/descending and overlapping transition
        //*****************************************************
         
        //****PASS CASES*************************************************************************
         
         //3.5f,3.4f,3.0f,2.9f,2.5f,2.4f   //descending descending descending  ok, ticker=ok
         //3.5f,3.4f,3.0f,2.9f,4.5f,4.6f   //descending descending ascending  ok, ticker=ok
        
         //3.0f,2.7f,2.5f,2.4f,2.5f,2.6f  //changed last digit, want to see how it handles this  ****FAIL************** ok, ticker=ok
         //3.5f,3.4f,3.5f,3.6f,32.1f,32.2f   //descending ascending ascending  ok, ticker=ok
       
         //5.0f,4.9f,4.8f  //most basic desecnding  ok, ticker=ok
         //47.3f, 47.4f,47.5f  //(RESOLVED)  ok, ticker=ok
          //47.3f, 47.4f  //ok, ticker=ok
         //3.0f,2.7f,2.5f,2.4f,2.5f,2.6f  //(RESOLVED)  ok, ticker=ok
         //3.0f,2.7f,2.5f,2.4f,2.5f,4.0f  //exploring above scenario but the descend is slightly longer  ***FAIL**********  (RESOLVED) ok, ticker=ok
         
         //2.5f,2.4f,2.5f  //ok, ticker=ok
        
        //3.5f,3.6f, 3.5f, 3.6f,3.7f,3.8f, 3.7f,3.4f,3.0f,2.9f,2.5f,2.4f //ok , ticker fail A-D (*A*-D)
        
        //3.5f,3.6f, 3.5f, 3.6f, 3.5f,3.4f,3.0f,2.9f,2.5f,2.4f  //ascending descending ascending  descending descending descending ok, ticker=ok
        //4.6f,3.5f,3.4f,3.5f,3.4f,6.7f,6.9f   //descending ascending descending        (NOW FAILS)----------------------------- ok, ticker=ok
         
        //3.5f,3.6f,40.0f,40.1f   //it has not written  3.5f,3.6f,40.0f  ok, ticker=ok
        
        //new test cases exploring standalone repeat numbers
         
        //40.2f,40.2f,96.0f, 96.1f   //(standalone at front) ok, ticker=ok
        //40.2f,40.2f,96.0f, 96.0f,33.4f   //(two standalones at front, repeat)  ok, ticker=ok
        //40.1f, 45.1f  //(it merges them, very basic error in my logic to resolve)  ok, ticker=ok
        
        //3.5f,3.6f,40.0f,40.1f   //(simple ascending, ascending) ok, ticker=ok
        //3.5f,3.6f,40.0f,40.1f,56.2f   //(simple ascending, ascending, then standalone) ok, ticker=ok
        //3.5f,3.6f,40.0f,40.1f,56.2f,56.3f  //ascending ascending ascending   (writing 3.5->40.1, 56.2->56.3) ok,ticker=ok
        //3.5f,3.6f,40.1f,4.1f,40.0f   //ascending standalone  (it has only written standalone cases) ok, ticker=ok
       
        //ok, ticker=
        //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, 
       
        //this now fails, so it appears that it needs to perform 0000Write when k==1-
      
        //3.5f,3.6f,3.5f,40.0f  // (simple ascending, then standalone)  ok, ticker=ok
        //3.6f,3.5f,3.6f,40.0f  // (simple ascending, then standalone)  ok, ticker=ok
        
        //3.0f,2.5f,2.4f,2.5f,2.8f,2.9f  //(This is fine, but the next example, it writes 2.4->2.5 twice). ok, ticker=ok
        //3.0f,2.7f,2.5f,2.4f,2.5f,4.0f  //exploring above scenario but the descend is slightly longer  ***FAIL**********  (RESOLVED) ok, ticker=ok
        //40.2f,40.2f,96.0f, 96.1f,3.0f,3.0f   //(standalone at end both not writteny)  ok, ticker=ok
         //47.3f,40.0f,40.1f,3.5f   //failing adding range twice  ok, ticker=ok
        //96.0f, 96.1f, 40.1f, 40.1f  //(does not write standalones at end) ok, ticker=ok
        //56.0f,96.0f, 96.1f,96.2f,96.3f, 40.1f, 40.1f,40.2f,40.2f  //(does not write standalones at end due to skipping iteration) ok, ticker=ok
        
        
        //LATE TEST CASES**************************************************************************
        //***ISSUE WHEN 2 DESCENDING AT END*** (RESOLVED)
        //3.5f,3.6f,3.7f,3.8f,3.7f     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%   ok, ticker=ok
        //3.5f,3.6f,3.7f,3.8f,3.7f,3.9f,4.0f  //ok, ticker=ok
        //***ISSUE WHEN 4 DESCENDING AT END***
        //3.5f,3.6f,3.7f,3.8f,3.7f,45.5f,45.4f  //ok, ticker=ok
        //*****NO ISSUE 2 ASCENDING AT END
        //3.5f,3.4f,3.35f,3.6f,3.7f,3.8f  //ok, ticker=ok
        //3.7f,3.8f,3.7f,3.9f,4.0f,3.5f,3.6f,3.7f,3.8f,3.7f,45.5f,45.4f,3f,3.2f,3.3f  //ok, ticker=fail   A (*A*-D)
        //3.7f,3.8f,3.7f,4.1f,4.0f,3.5f,3.6f,3.7f,3.8f,3.7f,45.5f,45.4f,3f,3.2f,3.3f  //ok, ticker=fail   D (*A*-D)
        
        //used to test the ticker
        //3.5f,3.4f,3.35f,3.6f,3.7f,3.8f,3.7f,3.5f,3.6f,3.7f,3.8f,3.7f  //ok, ticker=ok
        //3.5f,3.6f,3.7f,3.8f, 3.7f,3.5f,3.6f,3.7f,3.8f,3.7f,3.6f,3.5f  //ok, ticker= fail A-D  (*A-D)
         
        //ISSUES THESE //Related to oversized or undersized ticker, it relates to transition and also standalone value occuring prior to it
        //35.1f, 35.2f, 35.3f, 35.2f, 35.1f, 85.6f  //ticker incorrect**********************  //ok, ticker=ok  A D S 
        //3.5f,3.6f,3.7f,3.8f, 3.7f,  3.5f,  3.6f,3.7f,3.8f,  3.7f,3.6f,  3.5f,3.6f,3.7f,3.8f  //ok, ticker=fail   (A-D) (*A-D) A
        //5.0f, 48.5f,28.6f, 28.5f, 28.4f, 28.3f, 28.2f, 3.5f,3.6f, 3.5f   //ok, ticker=ok  //issues     D (A - too large) D
        //28.6f, 28.5f, 28.4f, 28.3f, 28.2f, 3.5f,3.6f, 3.5f  //rule does not work DAD  //issues  ok, ticker=ok
        //It appears that ascendingcounter SHOULD NOT BE INCREASED IN THE NEW RULE IN THE COMPLETETICKER METHOD WHERE 
        //ascendingcounter==1 and descending in both directions....
         
        //29.9f,30.0f,28.9f,28.8f,28.9f,29.0f  //no issues ADA      //ok, ticker=ok
          
        //1.1f,1.2f,1.3f,1.2f,1.1f  //ok, ticker=ok
        //1.5f,1.4f,1.3f,1.4f,1.5f   //ok, ticker=ok
          
        //2.9f,2.8f,2.7f,2.6f,2.5f,2.4f,2.3f,2.4f,2.5f,2.6f,2.7f,2.8f,2.7f,4.0f  //ok, ticker=ok
        //3.0f,3.1f,3.2f,3.3f,3.2f,3.1f,3.2f,4.0f  //ok, ticker=ok
         
        //*****NO ISSUE 3 DESCENDING AT END
        //3.5f,3.6f,3.7f,3.8f,3.7f,3.6f  //ok, ticker=ok
        //Now combining lots of these together...
         
        //3.5f,3.6f,3.7f,3.5f,3.4f,3.3f,3.2f,25.0f,25.1f,49,3.0f,3.33f,3.7f,3.6f  //ok, ticker=ok
        //3.5f,3.6f,3.7f,3.8f,3.7f,45.5f,45.4f  //ok, ticker=ok
        //3.5f,3.6f,3.7f,3.8f,3.7f,3.8f     //ok, ticker=ok
        
        //3.5f,3.6f,3.5f   //it is worth focussing on most simplest example to understand   //ok, ticker=ok
        
        //3.5f,3.6f, 3.5f, 3.6f, 3.5f,3.4f,3.0f,2.9f,2.5f,2.4f  //ascending descending ascending  descending descending descending   //ok, ticker=ok
        //so need to configure variable 
        
        //3.5f,3.6f,3.5f,3.1f,3.0f,2.9f   //ascending descending descending   //ok, ticker=ok
        //3.5f,3.6f,3.5f,3.6f   //ascending descending ascending   //ok, ticker=ok
        //3.5f,3.6f,3.5f,3.2f,3.1f   //ascending descending descending  //ok, ticker=ok
       
        //Extreme late test case scenario
        //0.1f,0.2f,0.1f   //ok, ticker=ok
       
        //85.3f, 85.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 63.5f, 14.9f, 14.9f   //ok, ticker=ok
        //56.0f,96.0f, 96.1f,96.2f,96.3f, 40.1f, 40.1f,40.2f,40.2f  //(does not write standalones at end due to skipping iteration)   //ok, ticker=ok
        //56.0f,96.0f, 96.1f,96.2f,96.3f, 40.1f, 40.3f,40.2f,40.2f,40.1f,40.3f,40.5f  //(does not write standalones at end due to skipping iteration)  //ok, ticker=ok
        //28.6f, 28.5f, 28.4f, 28.3f, 28.2f, 28.1f, 28.0f, 39.0f, 33.6f, 33.7f, 33.8f  //ok, ticker=ok
       
        //late testing ticker
        //4.9f, 4.8f, 4.7f, 4.6f,4.7f, 4.8f, 4.9f, 5.0f, 48.5f,28.6f, 28.5f, 28.4f, 28.3f, 28.2f, 3.5f,3.6f, 3.5f  //ok, ticker=ok
        //85.3f, 85.2f, 19.6f, 19.7f, 19.8f, 19.9f, 7.0f,6.9f,6.8f,6.7f, 20.0f, 19.9f, 19.8f, 63.5f, 14.9f, 14.9f    //ok, ticker=ok
        //4.9f, 4.8f, 4.7f, 4.6f,5.0f,4.5f  //ok, ticker=ok
       
        //LATE TESTING DUE TO HIGH COUNT OF DESCENDING IN TICKER
        //7.1f,6.5f,6.4f,6.3f,6.2f//no issues  //ok, ticker=ok
         
        //so need to set flag if tickerCounter>1
        //4.9f, 4.8f, 4.7f, 10.0f,5.0f,4.9f,4.8f,4.7f,5.0f,4.9f,4.8f   //(no issues if 3 descending chains) //ok, ticker=ok
        
        //7.1f,7.2f,6.5f,6.4f,6.3f,6.2f, 8.0f //issues with standalone at end  ok, ticker=ok
         
        //EXAMPLE OF ISSUE WITH TICKER
        //3.5f,3.6f, 3.5f, 3.6f, 3.5f,3.4f,3.0f,2.9f,2.4f,2.5f  //ok, ticker=ok
        //40.1f,35.1f, 35.2f, 35.3f, 35.2f, 35.1f, 85.6f    //ISSUES  //ok, ticker=ok
        
        //use as example where no isues A-D A-D if the descending is at end
        //3.5f,3.4f,3.35f,3.6f,3.7f,3.8f,3.7f,3.5f,3.6f,3.7f,3.8f,3.7f  //fixed  //ok, ticker=ok 
    
        //4.1f,4.0f,3.9f,3.8f,3.9f,40.f   //issue with counter for descending  //ok, ticker=ok
        //3.5f,3.6f,3.7f,3.8f,3.7f,3.6f                //ok, ticker=ok
          
         //3.5f,3.6f,3.5f,3.1f,3.0f,2.9f   //ascending descending descending     //ISSUES  //ok, ticker=ok
         
         //4.9f, 4.8f, 4.7f, 4.6f,4.7f, 4.8f, 4.9f, 5.0f, 48.5f,28.6f, 28.5f, 28.4f, 28.3f, 28.2f, 3.5f,3.6f, 3.5f  //ok, ticker=ok
         //0.1f,0.2f,0.1f           //ascending descending  //ok, ticker=ok
         //3.5f,3.6f,3.5f,3.2f,3.1f   //ascending descending descending        //ok, ticker=ok
          
         //3.3f,3.2f,3.3f,3.2f,3.3f,3.3f,3.3f,3.4f  //ok, ticker=ok
         //4.1f,4.0f,3.9f,3.8f,3.8f,3.9f   //fixed  //ok, ticker=ok    UP TO HERE------------------------------------------
          
        //issue with repeat standalone appearing
         //4.1f,4.0f,3.9f,3.8f,3.8f,3.9f   //fixed  //ok, ticker=ok
         //3.5f,3.6f,3.7f,3.8f,3.8f,3.9f   //fixed   ok, counter=ok
          
         //4.1f,4.0f,3.9f,3.8f,3.8f,3.7f,3.6f,3.9f  //ISSSUESS!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1  //ok, ticker=ok
          
         //4.1f,4.0f,7.2f,7.2f,3.9f,3.8f,3.8f,4.4f,4.3f,3.7f,3.7f  //ISSSUESS with the counter-------- //ok, ticker=ok
        
        //2.0f,3.45f,2.1f,2.2f,3.67f,3.9f,3.8f,3.5f  //ok, ticker=ok
        
        //4.9f,7.2f,3.5f,3.6f,3.7f,3.8f,3.8f,3.9f   //trying standalones at the front,  //ok, ticker=ok
         
        //4.9f,7.2f,3.5f,3.6f,43.0f,49.0f,3.7f,3.8f,3.8f,3.9f   //trying standalones at end, //ok, ticker=ok
         
        //4.9f,7.2f,3.5f,3.6f,43.0f, 49.0f,48.9f,48.7f,48.7f,48.6f,40.0f,3.7f,3.8f,3.8f,3.9f   //trying standalones i between.. //ok, ticker=ok
        //25.3f, 72.8f,42.5f, 74.5f, 74.4f, 74.3f, 74.2f, 74.1f, 74.2f, 74.3f, 74.4f,74.5f //issue with ticker at end, value too small, fixed //ok, ticker=ok
         
        //USED FOR LATE TESTING OF CODE - ALL LATE PROBLEMS OF STANDALONE IN BETWEEN WHICH ARE PART OF THE RANGE
        //4.9f,5.0f,5.1f,5.1f,5.2f,4.0f //standalone is not at k==nums.length-2,  //ok, ticker=ok
           
        //issue now is that having 4.9f,4.8f,4.8f,5.0f,5.1f,5.1f,5.2f,4.0f 
        //it does not wrrite any standalone for repeating 5.1f.
        //this is correct.. But we have nothing to differentiate it from a transition
        //so i would need more screen comments
        //i lack outputs in the section around standalone numbers
         
        //THESE ARE ALL PART OF LAST MY APPROACH DOCUMENT (NOT CONFIDENT ABOUT TICKER ON ALL OF THESE)
        //4.9f,4.8f,4.8f,5.0f,5.1f,5.1f,5.2f,4.0f  // -------------------------------------------- //ok, ticker=ok
        //4.9f,4.8f,4.8f,5.0f,4.9f,4.9f,5.1f,5.1f,5.2f,4.0f     //ok, ticker=ok
        //4.8f,4.9f,4.9f,4.7f,5.9f,5.9f,6.1f,6.1f,6.2f,4.0f  //ok, ticker=ok
        //4.7f,4.8f,4.9f,5.0f,5.0f,4.9f,4.8f,4.7f    //ok, ticker=ok
                
        //5.3f,5.2f,5.1f,5.0f,5.0f,5.1f,4.8f,4.7f    //ok, ticker=ok
        //5.3f,5.2f,5.1f,5.0f,5.0f,5.0f,5.1f,4.8f,4.7f    //ok, ticker=ok
                
        //4.7f,4.8f,4.9f,5.0f,5.0f,5.0f,4.9f,4.8f,4.7f  //ok, ticker=ok
        
        //47.3f,47.4f,47.3f          //ok, ticker=ok
        //4.7f,4.8f,4.9f,5.0f,5.0f,4.9f  //ok, ticker=ok   ***FAIL ******* NOW FIXED
        //4.7f,4.8f,4.9f,5.0f,4.8f,4.9f,5.0f,5.0f,4.9f  //ok, ticker=ok
                    
        //4.7f,4.8f,4.9f,5.0f,5.0f,5.0f,4.9f  //ok, ticker=ok
        //5.3f,5.2f,5.1f,5.0f,5.1f,5.2f,5.3f   //ok, ticker=ok
        //5.3f,5.2f,5.1f,5.0f,5.0f,5.0f,5.1f,5.2f,5.3f   //ok, counter issue at end,   //ok, ticker=ok
        //5.3f,5.2f,5.1f,5.0f,5.0f,5.1f   //ok, //ok, ticker=ok
        //4.7f,4.8f,4.9f,5.0f,5.0f,5.0f,4.9f //ok, ticker=ok
        //4.7f,4.8f,4.9f,5.1f,5.1f,4.9f,4.8f,4.7f  //ok, ticker=ok
        //5.3f,5.2f,5.1f,5.4f,5.4f,5.2f,5.1f  //ok, ticker=ok
        //5.3f,5.2f,5.7f,5.7f,5.1f,5.1f  //ok, ticker=ok
        //4.7f,4.8f,4.9f,5.1f,5.1f,5.3f,5.2f,5.7f,5.7f,5.1f,5.1f,4.9f,4.8f,4.7f   //ok, ticker=ok
            
        //3.4f,3.5f,3.6f,3.6f,3.5f,3.4f,3.3f,3.2f, 3.3f,3.3f,3.3f,3.4f,3.6f,55.0f  //ok, ticker=ok
         
        //3.3f,3.3f,3.4f,3.3f,3.2f  //issues------------------------------------------------//ok, ticker=ok
           
        //3.3f,3.3f,3.2f,3.3f,3.4f  //ok, ticker=ok
        //3.3f,3.3f,3.3f,3.3f,3.3f,3.2f,3.3f,3.4f  //ok, ticker=ok
        //3.3f,3.3f,3.3f,3.2f,3.2f,3.2f,3.1f,3.1f //ok, ticker=ok
           
        //3.3f,3.3f,3.3f,3.6f,3.6f  //ok, ticker=ok
           
        //3.4f,3.4f,3.4f,3.3f,3.4f,3.2f //ok, ticker=ok
        //3.3f,3.3f,3.3f,3.6f,3.6f,3.5f,3.5f,3.4f,3.3f  //ok, ticker=ok
         
         //mixing several test cases
         //3.4f,3.4f,3.3f,3.3f,3.3f,3.4f,4.7f,4.8f,4.9f,5.0f,5.0f,5.0f,4.9f,3.3f,3.2f,3.4f,3.3f,3.4f,3.2f  ///ok, ticker=ok
         //4.7f,4.8f,4.9f,5.0f,5.0f,5.0f,4.9f,3.3f,3.2f,3.4f,3.3f,3.4f,3.2f  //ok, ticker=ok
         
         
         //chatGPT extract 3 - 3000 numbers
         //47.3f, 47.3f, 47.2f, 90.6f, 90.6f, 73.9f, 74.0f, 74.1f, 74.2f, 37.6f, 37.7f, 37.8f, 37.9f, 38.0f, 42.7f, 42.7f, 33.4f, 33.5f, 33.6f, 33.7f, 33.8f, 33.9f, 34.0f, 88.4f, 88.5f, 88.6f, 88.7f, 32.2f, 32.2f, 32.2f, 32.2f, 31.1f, 31.1f, 31.1f, 31.1f, 4.4f, 4.4f, 4.4f, 25.3f, 25.4f, 25.5f, 25.6f, 25.7f, 25.8f, 25.9f, 26.0f, 19.2f, 19.2f, 19.2f, 19.3f, 83.4f, 83.3f, 83.2f, 83.1f, 83.0f, 82.9f, 56.0f, 35.304f, 39.8f, 39.7f, 39.6f, 39.5f, 39.4f, 98.7f, 98.7f, 98.7f, 98.7f, 10.6f, 10.6f, 10.5f, 24.6f, 24.6f, 24.6f, 24.5f, 24.6f, 24.6f, 24.7f, 52.2f, 52.2f, 52.2f, 52.2f, 34.7f, 34.7f, 34.6f, 16.0f, 16.0f, 16.0f, 57.84f, 97.0f, 97.0f, 97.0f, 97.0f, 26.9f, 26.8f, 24.9f, 24.9f, 25.0f, 95.6f, 95.6f, 95.5f, 95.77f, 70.5f, 70.5f, 70.5f, 70.5f, 98.9f, 98.9f, 34.3f, 34.4f, 34.5f, 34.6f, 34.7f, 34.8f, 34.9f, 35.0f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 75.9f, 75.8f, 75.7f, 75.6f, 75.5f, 75.4f, 75.3f, 75.2f, 75.1f, 75.0f, 40.34f, 84.9f, 85.0f, 85.1f, 85.2f, 85.3f, 85.4f, 22.5f, 22.6f, 22.7f, 22.8f, 22.9f, 23.0f, 20.8f, 52.7f, 52.8f, 52.8f, 52.8f, 52.9f, 80.0f, 79.9f, 79.9f, 80.0f, 55.2f, 55.2f, 55.3f, 72.5f, 72.4f, 72.3f, 72.2f, 22.1f, 22.1f, 15.3f, 15.3f, 77.8f, 77.9f, 78.0f, 78.1f, 78.2f, 78.3f, 78.4f, 78.5f, 78.6f, 76.52f, 20.5f, 20.5f, 93.7f, 93.7f, 93.7f, 65.0f, 65.1f, 65.1f, 65.2f, 91.4f, 91.4f, 91.4f, 91.4f, 64.7f, 64.7f, 64.7f, 64.8f, 64.7f, 64.7f, 64.8f, 57.0f, 57.0f, 75.4f, 75.4f, 75.4f, 75.5f, 43.6f, 43.5f, 43.4f, 43.3f, 43.2f, 43.1f, 43.0f, 42.9f, 42.8f, 63.6f, 63.6f, 63.6f, 63.6f, 63.7f, 63.7f, 63.7f, 63.8f, 33.8f, 33.7f, 33.6f, 83.4f, 83.4f, 83.4f, 14.0f, 47.1f, 47.2f, 47.3f, 47.4f, 47.5f, 47.6f, 34.4f, 34.5f, 34.6f, 34.7f, 35.8f, 35.7f, 35.6f, 35.5f, 35.4f, 35.3f, 35.2f, 35.1f, 35.0f, 35.1f, 35.1f, 35.2f, 35.1f, 35.1f, 35.1f, 35.2f, 35.1f, 35.1f, 35.1f, 35.2f, 21.1f, 21.1f, 21.1f, 71.3f, 71.3f, 71.2f, 71.1f, 71.1f, 71.2f, 20.2f, 20.1f, 20.0f, 19.9f, 19.8f, 19.7f, 19.6f, 30.8f, 30.8f, 30.8f, 30.8f, 11.4f, 11.4f, 11.4f, 1.0f, 1.0f, 1.1f, 1.1f, 1.1f, 1.2f, 61.5f, 61.5f, 61.5f, 61.4f, 61.4f, 61.4f, 22.0f, 59.6f, 59.6f, 59.6f, 75.4f, 75.3f, 75.2f, 75.1f, 75.0f, 75.0f, 75.0f, 75.1f, 86.693f, 8.8f, 8.8f, 0.9f, 0.9f, 0.9f, 0.9f, 9.5f, 9.4f, 9.4f, 9.5f, 9.6f, 9.6f, 9.6f, 9.7f, 60.1f, 60.2f, 72.5f, 72.4f, 72.3f, 72.2f, 72.1f, 72.0f, 22.2f, 22.2f, 22.2f, 22.2f, 22.1f, 22.1f, 22.2f, 96.23f, 96.3f, 96.3f, 96.3f, 96.4f, 11.4f, 11.4f, 11.4f, 11.4f, 6.3f, 6.3f, 6.4f, 44.7f, 44.6f, 44.5f, 44.4f, 44.3f, 44.2f, 44.1f, 59.0f, 59.0f, 58.9f, 31.4f, 31.4f, 31.5f, 31.6f, 31.6f, 31.6f, 31.7f, 83.6f, 83.5f, 83.4f, 83.3f, 83.2f, 83.1f, 83.0f, 82.9f, 82.8f, 82.7f, 86.5f, 86.6f, 86.7f, 86.8f, 86.9f, 87.0f, 27.9f, 27.9f, 27.9f, 27.9f, 75.9f, 75.9f, 75.9f, 75.9f, 69.2f, 69.1f, 69.0f, 12.0f, 12.1f, 13.5f, 13.5f, 13.5f, 13.6f, 19.0f, 47.1f, 42.1f, 42.2f, 42.3f, 42.4f, 38.2f, 38.1f, 38.0f, 37.9f, 37.8f, 37.7f, 37.6f, 28.7f, 28.7f, 28.7f, 12.2f, 12.3f, 66.9f, 66.9f, 66.8f, 79.7f, 79.7f, 79.7f, 79.6f, 84.6f, 84.6f, 84.6f, 84.5f, 45.4f, 45.4f, 45.4f, 45.3f, 33.6f, 33.6f, 33.6f, 33.7f, 51.5f, 51.5f, 48.6f, 48.7f, 48.8f, 48.9f, 49.0f, 49.1f, 49.2f, 49.3f, 49.2f, 49.2f, 49.2f, 49.3f, 33.8f, 90.368f, 46.0f, 46.0f, 46.0f, 46.1f, 46.1f, 46.2f, 17.0f, 16.9f, 16.8f, 16.7f, 16.6f, 16.5f, 16.4f, 16.3f, 50.02268f, 11.9f, 9.4f, 9.4f, 9.4f, 9.5f, 9.6f, 9.6f, 9.7f, 29.8f, 29.8f, 29.8f, 10.8f, 10.8f, 10.8f, 38.9f, 38.8f, 38.7f, 38.6f, 38.5f, 54.73415f, 82.5f, 82.5f, 82.5f, 69.45f, 50.0f, 50.1f, 50.2f, 50.1f, 50.1f, 50.1f, 50.2f, 27.41358f, 77.6f, 49.2f, 49.2f, 49.2f, 49.3f, 40.2f, 40.3f, 40.4f, 40.5f, 87.2f, 87.2f, 87.2f, 87.1f, 87.2f, 87.2f, 87.3f, 82.5f, 82.5f, 61.5f, 61.4f, 61.3f, 98.358f, 3.3f, 3.2f, 3.1f, 3.0f, 2.9f, 2.8f, 2.7f, 3.1f, 3.1f, 21.34312f, 48.2f, 48.2f, 48.2f, 48.2f, 41.4f, 41.4f, 41.4f, 41.3f, 64.60801f, 73.6f, 73.6f, 73.6f, 73.7f, 40.8f, 40.7f, 40.6f, 40.5f, 40.4f, 40.3f, 40.32f, 63.9f, 63.9f, 28.4f, 28.4f, 28.4f, 26.0f, 26.0f, 26.0f, 26.0f, 80.0f, 80.0f, 80.0f, 80.0f, 81.2f, 19.0f, 19.0f, 19.0f, 19.0f, 30.03288f, 17.0f, 17.0f, 30.8f, 30.8f, 93.2f, 93.2f, 93.3f, 93.2f, 93.2f, 93.2f, 93.3f, 96.134f, 50.5f, 50.5f, 50.4f, 73.13f, 70.7f, 70.6f, 70.5f, 69.79874f, 1.9f, 1.9f, 2.0f, 63.4f, 63.4f, 66.3f, 66.4f, 66.5f, 53.3f, 53.3f, 53.3f, 53.3f, 27.3f, 27.3f, 27.3f, 27.3f, 82.0f, 82.0f, 81.9f, 80.116f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 87.7f, 87.7f, 87.7f, 87.6f, 62.2f, 62.2f, 62.2f, 62.3f, 81.33f, 27.5f, 27.6f, 27.7f, 27.8f, 86.2f, 86.3f, 86.4f, 86.5f, 48.9f, 48.8f, 48.7f, 48.6f, 20.2f, 20.3f, 20.4f, 20.5f, 20.6f, 20.7f, 20.8f, 20.9f, 21.0f, 98.2f, 98.1f, 98.0f, 97.9f, 97.8f, 97.7f, 97.7f, 97.8f, 9.7f, 9.7f, 83.3f, 83.3f, 83.2f, 83.1f, 83.1f, 83.2f, 29.3f, 29.4f, 29.5f, 29.6f, 29.7f, 29.8f, 29.9f, 30.0f, 30.1f, 30.2f, 84.5f, 84.6f, 84.7f, 84.8f, 84.9f, 85.0f, 85.1f, 85.2f, 86.5f, 86.6f, 86.7f, 86.8f, 86.9f, 87.0f, 87.1f, 23.0f, 23.1f, 23.2f, 23.3f, 23.4f, 23.5f, 23.6f, 23.7f, 23.8f, 23.9f, 17.3f, 17.4f, 17.5f, 17.6f, 17.7f, 17.8f, 17.9f, 18.891f, 18.8f, 18.8f, 18.8f, 18.9f, 50.8f, 50.8f, 51.7f, 51.8f, 86.7f, 86.8f, 86.9f, 87.0f, 48.6f, 48.5f, 48.4f, 48.3f, 48.2f, 48.1f, 77.3f, 77.4f, 77.5f, 77.6f, 45.4f, 45.5f, 45.6f, 45.7f, 45.8f, 76.0f, 76.1f, 76.2f, 76.3f, 76.4f, 76.5f, 26.6f, 26.5f, 83.6f, 83.5f, 83.4f, 35.4f, 35.4f, 35.4f, 35.5f, 66.4f, 66.4f, 66.4f, 36.0f, 36.0f, 36.0f, 36.0f, 62.1f, 62.0f, 61.9f, 61.8f, 61.7f, 61.6f, 61.5f, 61.4f, 54.6f, 54.5f, 54.4f, 54.3f, 15.3f, 15.3f, 15.3f, 15.2f, 63.7f, 63.7f, 5.7f, 5.7f, 5.6f, 66.7f, 66.7f, 34.4f, 34.4f, 34.3f, 12.4f, 12.4f, 12.3f, 79.3f, 79.4f, 79.5f, 79.6f, 79.7f, 79.8f, 79.9f, 80.0f, 73.6f, 73.7f, 73.8f, 73.9f, 74.0f, 74.1f, 74.0f, 74.0f, 74.0f, 74.1f, 53.7f, 53.7f, 53.6f, 53.6f, 53.6f, 53.7f, 23.9f, 24.0f, 59.8f, 59.7f, 92.1f, 92.1f, 92.1f, 92.0f, 61.0f, 65.9f, 21.4f, 21.3f, 21.2f, 21.1f, 21.1f, 21.2f, 37.4f, 37.3f, 37.2f, 37.1f, 37.0f, 36.9f, 36.8f, 18.2f, 18.1f, 18.0f, 17.9f, 17.8f, 17.7f, 17.6f, 17.5f, 17.4f, 17.3f, 17.4f, 17.4f, 17.5f, 25.1f, 25.1f, 84.0f, 84.1f, 84.2f, 84.3f, 84.4f, 84.5f, 84.6f, 84.7f, 68.31f, 82.9f, 82.9f, 33.7f, 33.7f, 33.7f, 33.7f, 67.94f, 29.4f, 29.3f, 29.2f, 29.1f, 29.0f, 28.9f, 28.8f, 28.7f, 28.6f, 28.5f, 64.7f, 64.6f, 64.5f, 44.4f, 44.3f, 44.2f, 44.1f, 44.0f, 43.9f, 43.8f, 43.7f, 75.7f, 75.8f, 75.9f, 76.0f, 76.1f, 90.3f, 90.4f, 90.5f, 90.6f, 90.7f, 90.7f, 90.7f, 90.8f, 61.298f, 8.7f, 8.7f, 76.2f, 76.2f, 76.1f, 86.8f, 86.8f, 86.8f, 50.1f, 50.1f, 50.1f, 50.1f, 97.2f, 97.2f, 97.3f, 63.9f, 64.0f, 64.1f, 64.2f, 64.3f, 64.4f, 64.5f, 64.6f, 64.7f, 64.7f, 64.7f, 64.8f, 65.7f, 65.8f, 65.9f, 66.0f, 66.1f, 66.2f, 66.3f, 66.4f, 66.5f, 56.3f, 56.2f, 56.1f, 84.7f, 84.8f, 26.9f, 26.8f, 26.7f, 26.6f, 98.4f, 98.3f, 98.2f, 98.1f, 98.0f, 97.9f, 97.8f, 97.7f, 97.6f, 94.7f, 94.8f, 61.6f, 61.6f, 61.6f, 61.6f, 61.5f, 61.5f, 61.5f, 61.6f, 90.1f, 90.1f, 90.1f, 90.2f, 41.62407f, 1.6f, 1.7f, 1.8f, 72.449f, 45.5f, 99.2f, 99.2f, 27.7f, 27.7f, 27.7f, 27.8f, 96.8f, 96.8f, 96.8f, 96.8f, 64.3f, 64.2f, 64.1f, 64.0f, 63.9f, 63.8f, 63.7f, 63.6f, 63.5f, 63.4f, 81.1f, 81.1f, 64.3f, 64.2f, 64.1f, 16.0f, 15.9f, 15.8f, 15.7f, 15.6f, 15.5f, 15.4f, 95.2f, 95.2f,95.2f, 95.2f, 59.2f, 59.1f, 59.0f, 58.9f, 21.9f, 22.0f, 21.9f, 21.9f, 22.0f, 12.6f, 12.7f, 12.8f, 49.8f, 49.7f, 94.0f, 93.9f, 93.9f, 94.0f, 89.0f, 30.3f, 30.3f, 30.3f, 30.3f, 17.9f, 17.9f, 17.9f, 17.9f, 9.9f, 9.8f, 9.7f, 9.6f, 73.1f, 73.1f, 73.1f, 73.1f, 25.3f, 25.2f, 25.1f, 25.0f, 24.9f, 24.8f, 24.7f, 80.6f, 80.7f, 80.8f, 62.6f, 62.5f, 62.4f, 62.3f, 74.1f, 74.1f, 74.1f, 84.8f, 84.8f, 84.7f, 80.6f, 80.7f, 80.8f, 80.9f, 81.0f, 81.1f, 81.2f, 81.3f, 81.4f, 81.4f, 81.5f, 81.4f, 81.4f, 81.5f, 69.5f, 69.4f, 69.3f, 69.2f, 69.1f, 69.0f, 68.9f, 68.8f, 68.7f, 35.5f, 35.6f, 35.7f, 35.8f, 35.9f, 36.0f, 36.1f, 21.4f, 18.097f, 18.0f, 18.0f, 18.0f, 18.1f, 95.4f, 95.5f, 95.6f, 95.7f, 95.8f, 95.9f, 96.0f, 96.1f, 88.8f, 88.8f, 88.8f, 88.9f, 92.1f, 92.0f, 91.9f, 91.8f, 59.4f, 59.4f, 59.4f, 59.3f, 17.7f, 17.6f, 17.5f, 17.4f, 73.6f, 33.9f, 55.6f, 55.6f, 32.6f, 32.6f, 32.6f, 32.6f, 92.7f, 92.8f, 92.9f, 93.0f, 93.1f, 93.2f, 93.3f, 76.1f, 76.1f, 76.1f, 76.1f, 29.1f, 29.1f, 29.1f, 29.2f, 87.5f, 87.5f, 87.6f, 87.6f, 87.7f, 21.3f, 21.4f, 21.5f, 21.6f, 21.7f, 21.8f, 21.9f, 22.0f, 22.1f, 22.2f, 24.7f, 24.7f, 24.6f, 11.7f, 11.8f, 11.9f, 12.0f, 12.1f, 12.2f, 12.3f, 44.1f, 44.1f, 44.1f, 1.0f, 0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 50.856f, 50.8f, 50.8f, 50.8f, 50.9f, 50.8f, 50.8f, 50.8f, 50.9f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 2.2f, 2.3f, 2.4f, 45.0f, 45.1f, 45.2f, 45.3f, 74.8f, 74.8f, 74.7f, 28.0f, 62.3f, 62.3f, 75.0f, 2.0f, 2.0f, 2.0f, 2.0f, 77.01852f, 76.9f, 76.9f, 76.9f, 77.0f, 11.3f, 11.3f, 11.3f, 11.3f, 30.3f, 30.3f, 30.3f, 30.3f, 52.2f, 52.2f, 52.3f, 52.3f, 52.3f, 52.4f, 58.342f, 58.2f, 58.2f, 58.3f, 21.9f, 22.0f, 22.0f, 22.1f, 26.7f, 26.8f, 38.6f, 38.7f, 38.8f, 38.9f, 39.0f, 39.1f, 39.2f, 39.3f, 39.4f, 61.2f, 61.3f, 61.4f, 61.5f, 61.6f, 61.7f, 61.8f, 83.0f, 32.2f, 32.3f, 32.4f, 32.5f, 40.24236f, 40.1f, 40.1f, 40.1f, 40.2f, 20.9f, 21.0f, 21.1f, 41.9f, 41.8f, 69.751f, 63.9f, 63.9f, 63.9f, 63.9f, 63.8f, 63.8f, 63.9f, 64.0f, 64.0f, 64.1f, 79.0f, 78.9f, 78.9f, 78.9f, 79.0f, 64.1f, 64.2f, 64.3f, 64.4f, 64.5f, 84.1f, 84.1f, 84.1f, 84.0f, 84.1f, 84.1f, 84.1f, 84.2f, 84.3f, 84.3f, 84.4f, 84.5f, 84.5f, 84.5f, 84.6f, 51.2f, 51.3f, 51.4f, 51.5f, 51.6f, 51.7f, 68.0f, 68.0f, 68.1f, 40.0f, 62.0f, 62.1f, 62.2f, 62.3f, 62.4f, 62.5f, 62.6f, 62.7f, 62.8f, 62.9f, 23.3f, 23.3f, 23.2f, 22.9f, 23.0f, 23.1f, 23.0f, 23.0f, 23.0f, 23.1f, 83.2f, 83.3f, 83.4f, 83.5f, 83.6f, 83.7f, 83.8f, 83.9f, 83.8f, 83.8f, 83.9f, 11.7f, 11.7f, 93.7f, 93.8f, 93.9f, 94.0f, 94.1f, 94.2f, 94.3f, 94.4f, 94.5f, 94.4f, 94.4f, 94.5f, 60.8f, 60.9f, 61.0f, 61.1f, 61.2f, 61.3f, 61.4f, 61.5f, 61.6f, 52.3f, 52.3f, 87.8f, 87.8f, 87.9f, 68.4f, 68.5f, 68.6f, 68.7f, 68.8f, 68.9f, 69.0f, 69.1f, 88.2f, 88.1f, 88.0f, 87.9f, 87.8f, 23.2f, 23.1f, 23.0f, 23.0f, 23.1f, 82.8f, 82.7f, 82.6f, 82.5f, 71.4f, 71.3f, 71.2f, 71.1f, 71.0f, 70.9f, 70.8f, 70.7f, 70.6f, 68.6f, 68.5f, 68.4f, 68.3f, 68.2f, 68.1f, 54.4f, 54.5f, 54.6f, 54.7f, 54.8f, 54.9f, 55.0f, 43.0f, 43.1f, 43.1f, 43.2f, 6.6f, 6.7f, 6.8f, 6.9f, 7.0f, 7.1f, 7.2f, 6.1f, 6.1f, 6.1f, 6.2f, 29.4f, 29.5f, 29.6f, 29.7f, 29.8f, 29.9f, 62.89f, 31.5f, 31.5f, 31.5f, 31.4f, 31.4f, 31.4f, 31.5f, 41.9f, 41.9f, 41.8f, 74.0f, 73.9f, 73.8f, 73.7f, 73.6f, 73.5f, 73.4f, 4.87f, 10.3f, 10.3f, 10.3f, 10.3f, 59.3f, 59.3f, 59.3f, 59.2f, 30.1f, 30.1f, 30.1f, 30.0f, 89.9f, 90.0f, 90.1f, 90.2f, 90.3f, 90.4f, 90.5f, 90.6f, 90.7f, 90.8f, 86.7f, 86.6f, 86.5f, 86.4f, 86.3f, 86.3f, 86.3f, 86.4f, 85.2f, 85.1f, 85.1f, 85.2f, 58.3f, 58.2f, 58.1f, 58.0f, 57.9f, 57.8f, 57.7f, 57.6f, 57.5f, 57.4f, 70.9f, 70.9f, 70.9f, 29.4f, 29.5f, 29.6f, 29.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f, 13.8f, 13.9f, 14.0f, 14.1f, 14.2f, 14.3f, 7.5f, 7.6f, 7.7f, 7.8f, 7.9f, 8.0f, 8.1f, 54.4f, 54.3f, 54.2f, 54.1f, 54.0f, 53.9f, 53.8f, 53.7f, 79.0f, 79.1f, 79.1f, 79.1f, 79.2f, 8.2f, 8.1f, 8.0f, 7.9f, 7.8f, 7.7f, 7.6f, 7.5f, 7.4f, 91.7f, 91.7f, 54.35f, 46.9f, 46.9f, 46.9f, 65.5f, 65.5f, 65.5f, 65.6f, 92.671f, 48.6f, 48.6f, 48.6f, 48.5f, 100.0f, 2.1f, 2.1f, 2.0f, 2.1f, 2.1f, 2.2f, 16.4f, 16.4f, 16.4f, 39.1f, 39.2f, 59.1f, 59.1f, 59.0f, 26.6f, 50.0f, 50.0f, 50.0f, 50.0f, 49.9f, 49.9f, 50.0f, 19.7f, 19.7f, 19.7f, 19.7f, 43.9f, 43.9f, 43.8f, 63.9f, 64.0f, 64.1f, 64.2f, 64.3f, 64.4f, 64.5f, 64.6f, 64.7f, 64.8f, 86.2f, 86.1f, 86.0f, 85.9f, 85.8f, 85.7f, 85.6f, 85.5f, 85.4f, 85.3f, 85.2f, 85.2f, 85.2f, 85.3f, 99.4f, 99.3f, 99.2f, 99.1f, 99.0f, 98.9f, 98.8f, 98.7f, 58.4f, 58.4f, 58.4f, 58.5f, 75.66034f, 75.8f, 75.8f, 75.9f, 34.9f, 34.9f, 34.8f, 72.5f, 72.5f, 72.5f, 72.6f, 29.1f, 29.1f, 97.5f, 97.5f, 97.6f, 97.6f, 97.7f, 54.0f, 54.0f, 53.9f, 19.7f, 19.7f, 19.7f, 19.7f, 19.7f, 19.7f, 19.8f, 46.1f, 46.0f, 45.9f, 45.8f, 45.7f, 45.6f, 19.8f, 19.8f, 48.5f, 91.8f, 91.8f, 91.8f, 91.7f, 6.9f, 6.8f, 6.7f, 6.6f, 6.5f, 62.3f, 62.2f, 31.3f, 31.3f, 31.3f, 31.2f, 88.5f, 88.5f, 88.5f, 88.4f, 73.5f, 73.5f, 73.4f, 77.5f, 77.5f, 97.5f, 97.5f, 97.6f, 86.5f, 86.6f, 86.7f, 86.8f, 86.9f, 87.0f, 87.1f, 64.5f, 64.4f, 64.3f, 64.2f, 64.1f, 57.809f, 48.9f, 48.9f, 48.9f, 48.8f, 48.8f, 48.9f, 58.783f, 58.9f, 58.9f, 59.0f, 60.3f, 60.4f, 60.5f, 60.6f, 60.7f, 60.8f, 60.9f, 61.0f, 61.1f, 71.179f, 24.827f, 87.4f, 87.4f, 87.4f, 87.4f, 90.6359f, 53.7f, 53.8f, 53.9f, 54.0f, 54.1f, 54.2f, 54.3f, 54.4f, 54.5f, 88.1f, 88.2f, 88.3f, 62.5f, 62.4f, 62.3f, 62.2f, 62.1f, 62.0f, 61.9f, 61.8f, 61.7f, 61.7f, 61.8f, 33.5f, 33.5f, 33.5f, 33.4f, 26.7f, 26.8f, 26.9f, 27.0f, 27.1f, 3.8f, 3.8f, 3.8f, 3.7f, 85.0f, 84.9f, 84.8f, 84.7f, 84.6f, 84.5f, 84.4f, 84.3f, 84.2f, 84.1f, 46.993f, 85.0f, 85.1f, 85.2f, 85.3f, 85.4f, 5.1f, 5.1f, 5.1f, 5.1f, 58.2f, 9.8f, 9.8f, 9.9f, 9.9f, 9.9f, 10.0f, 49.3f, 49.3f, 49.3f, 49.4f, 83.6f, 83.7f, 83.8f, 83.9f, 84.0f, 84.1f, 71.2f, 71.2f, 71.2f, 71.3f, 96.3f, 96.3f, 96.3f, 96.4f, 19.4f, 19.5f, 19.6f, 6.2f, 6.2f, 6.2f, 6.1f, 96.0f, 96.0f, 91.5f, 91.6f, 91.7f, 91.8f, 91.9f, 92.0f, 92.0f, 92.0f, 92.1f, 79.1f, 79.1f, 79.0f, 35.2f, 35.1f, 35.0f, 34.9f, 34.8f, 34.7f, 34.6f, 34.5f, 7.95f, 24.6f, 24.5f, 24.4f, 24.3f, 24.2f, 24.1f, 24.0f, 23.9f, 23.8f, 23.7f, 23.7f, 23.7f, 23.8f, 29.9f, 29.9f, 29.9f, 30.0f, 79.2f, 79.1f, 79.0f, 78.9f, 78.8f, 78.7f, 78.6f, 78.5f, 78.4f, 78.3f, 55.2f, 55.1f, 55.0f, 54.9f, 54.8f, 54.7f, 54.6f, 54.5f, 54.4f, 63.597f, 68.105f, 65.2f, 65.2f, 65.2f, 65.1f, 25.226f, 28.9f, 28.9f, 28.9f, 29.0f, 44.5f, 44.4f, 18.4f, 66.6f, 66.6f, 2.0f, 91.4f, 91.4f, 91.4f, 91.4f, 64.1f, 64.2f, 58.0f, 57.9f, 57.9f, 58.0f, 90.1f, 90.2f, 90.3f, 50.3f, 43.45487f, 23.2627f, 74.2f, 74.2f, 74.3f, 44.9f, 44.8f, 44.7f, 44.6f, 44.5f, 44.4f, 80.0f, 80.0f, 79.9f, 15.3f, 15.4f, 15.5f, 15.6f, 15.7f, 15.8f, 54.2f, 54.3f, 54.4f, 46.0f, 46.1f, 46.2f, 46.3f, 46.4f, 46.5f, 46.6f, 46.7f, 46.8f, 46.9f, 97.9f, 97.9f, 98.0f, 98.1f, 98.1f, 98.2f, 2.7f, 2.7f, 2.7f, 2.8f, 2.7f, 2.7f, 2.8f, 2.314f, 40.8f, 12.3f, 12.3f, 12.3f, 12.2f, 40.9f, 41.0f, 41.1f, 41.9f, 41.9f, 41.9f, 41.8f, 42.7f, 42.7f, 42.7f, 42.8f, 87.5f, 87.5f, 87.5f, 87.4f, 87.4f, 87.4f, 87.5f, 61.0f, 60.9f, 60.8f, 60.7f, 60.6f, 60.5f, 60.4f, 60.3f, 60.2f, 60.1f, 2.5f, 2.4f, 2.3f, 2.2f, 2.1f, 2.0f, 1.9f, 1.8f, 1.7f, 88.5f, 88.5f, 88.5f, 88.6f, 19.1f, 19.1f, 19.1f, 19.1f, 43.0f, 24.7f, 24.6f, 24.5f, 24.4f, 24.3f, 57.1f, 57.0f, 56.9f, 56.8f, 24.8f, 27.2f, 27.1f, 27.0f, 26.9f, 26.8f, 26.7f, 74.9f, 74.9f, 74.9f, 75.0f, 47.72725f, 47.6f, 47.6f, 47.6f, 47.7f, 11.5f, 11.4f, 11.3f, 11.2f, 11.1f, 18.8f, 18.8f, 18.7f, 18.4f, 18.3f, 18.2f, 18.1f, 18.0f, 17.9f, 17.8f, 17.8f, 17.9f, 11.1f, 11.0f, 10.9f, 96.6f, 96.7f, 96.8f, 96.9f, 97.0f, 97.1f, 97.2f, 97.3f, 97.4f, 79.5f, 79.5f, 79.4f, 91.5f, 91.5f, 25.6f, 25.6f, 25.5f, 41.4f, 41.5f, 41.6f, 41.7f, 41.8f, 41.9f, 42.0f, 42.1f, 42.2f, 42.3f, 72.4f, 72.3f, 72.2f, 72.1f, 69.3f, 69.3f, 69.3f, 69.2f, 69.2f, 69.2f, 69.3f, 69.4f, 69.4f, 69.5f, 69.6f, 69.6f, 69.6f, 69.7f, 13.1f, 13.2f, 13.3f, 13.4f, 13.5f, 13.6f, 13.7f, 13.8f, 13.9f, 89.0f, 6.3f, 6.3f, 6.3f, 6.2f, 6.2f, 6.2f, 6.3f, 56.8f, 56.7f, 56.6f, 56.5f, 56.4f, 56.3f, 56.2f, 56.1f, 56.0f, 25.9f, 25.9f, 52.6f, 52.7f, 52.8f, 22.6f, 22.5f, 22.4f, 22.3f, 22.2f, 22.1f, 22.0f, 39.4f, 39.3f, 39.2f, 39.1f, 39.0f, 38.9f, 38.8f, 64.76f, 90.9f, 91.0f, 91.1f, 91.2f, 91.3f, 91.4f, 91.5f, 91.6f, 10.5f, 10.6f, 10.7f, 10.8f, 10.9f, 88.6f, 88.6f, 72.98029f, 21.9f, 21.8f, 21.7f, 21.6f, 21.5f, 21.4f, 21.3f, 21.2f, 21.1f, 21.0f, 21.0f, 21.1f, 42.2f, 42.2f, 42.2f, 42.2f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f, 89.7f, 89.8f, 89.9f, 90.0f, 90.1f, 90.2f, 90.3f, 90.4f, 90.5f, 90.6f, 5.9f, 5.9f, 5.9f, 5.9f, 69.6f, 69.6f, 69.5f, 16.2f, 16.3f, 67.0f, 67.0f, 67.0f, 67.0f, 27.4f, 27.4f, 27.3f, 27.3f, 27.4f, 16.5f, 16.4f, 16.3f, 47.6f, 47.7f, 47.8f, 47.9f, 48.0f, 48.1f, 48.2f, 48.3f, 98.48781f, 67.0f, 34.2f, 34.3f, 34.4f, 34.5f, 34.6f, 34.7f, 26.4f, 26.3f, 26.2f, 26.1f, 26.0f, 70.2f, 70.2f, 45.9f, 45.9f, 45.9f, 45.8f, 45.7f, 45.7f, 45.8f, 53.7f, 53.7f, 53.7f, 63.7f, 63.6f, 63.5f, 63.4f, 63.3f, 63.2f, 63.1f, 63.0f, 62.9f, 62.8f, 62.7f, 62.7f, 62.8f, 60.1f, 60.1f, 59.8f, 59.7f, 59.6f, 59.5f, 59.4f, 59.3f, 59.2f, 59.1f, 59.0f, 58.9f, 96.8f, 96.8f, 96.8f, 8.5f, 8.6f, 8.7f, 8.8f, 8.9f, 9.0f, 32.4f, 32.4f, 32.4f, 32.4f, 16.6f, 16.6f, 16.6f, 73.7f, 73.8f, 73.9f, 74.0f, 74.1f, 74.0f, 74.0f, 74.0f, 74.1f, 35.9f, 35.9f, 2.0f, 62.8f, 62.8f, 62.9f, 61.6f, 61.6f, 61.6f, 61.5f, 61.4f, 61.4f, 61.4f, 61.5f, 88.6f, 88.6f, 88.5f, 86.9f, 86.8f, 86.7f, 86.6f, 86.5f, 86.4f, 86.3f, 86.2f, 86.1f, 86.0f, 86.0f, 86.0f, 86.1f, 34.37298f, 34.5f, 34.5f, 34.6f, 94.5f, 94.5f, 94.5f, 94.4f, 94.4f, 94.5f, 94.4f, 94.4f, 94.4f, 94.5f, 11.62904f, 28.0f, 28.1f, 28.2f, 28.3f, 28.4f, 28.5f, 28.6f, 28.7f, 28.8f, 28.9f, 15.6f, 15.6f, 15.5f, 92.7f, 92.7f, 92.6f, 3.6f, 3.7f, 3.8f, 3.9f, 4.0f, 50.4f, 50.5f, 84.0f, 84.1f, 84.2f, 84.3f, 84.4f, 84.5f, 84.6f, 84.7f, 84.8f, 84.9f, 63.6f, 63.5f, 63.4f, 63.3f, 63.2f, 63.1f, 63.0f, 62.9f, 31.3f, 31.4f, 31.5f, 31.6f, 31.7f, 31.8f, 31.7f, 31.7f, 31.7f, 31.8f, 39.8f, 39.7f, 39.6f, 39.5f, 39.5f, 39.6f, 43.5f, 43.5f, 15.0f, 15.0f, 14.9f, 14.8f, 14.8f, 14.9f, 7.1f, 7.2f, 7.3f, 7.4f, 7.5f, 7.6f, 7.7f, 7.8f, 55.7f, 55.7f, 55.6f, 5.5f, 5.5f, 5.5f, 93.84952f, 17.06976f, 72.62815f, 93.2f, 93.1f, 93.0f, 92.9f, 92.8f, 92.7f, 92.6f, 92.5f, 7.5f, 55.1f, 55.2f, 55.3f, 55.4f, 55.5f, 80.8f, 80.9f, 81.0f, 91.35152f, 86.6f, 86.6f, 86.7f, 13.1f, 13.1f, 13.1f, 13.1f, 48.8f, 48.8f, 48.8f, 1.0f, 21.3f, 21.2f, 21.1f, 21.0f, 20.9f, 20.8f, 20.7f, 20.6f, 71.76654f, 58.8f, 58.9f, 59.0f, 59.1f, 96.0f, 49.0f, 49.1f, 49.2f, 49.3f, 49.4f, 49.3f, 49.3f, 49.4f, 73.0f, 60.2f, 60.2f, 60.1f, 60.2f, 60.2f, 60.3f, 29.2f, 29.2f, 29.2f, 29.2f, 99.936f, 47.4f, 47.3f, 47.2f, 47.1f, 47.0f, 46.9f, 46.8f, 46.7f, 46.6f, 46.5f, 91.954f, 31.7f, 31.7f, 31.7f, 31.8f, 27.0f, 26.9f, 26.8f, 26.7f, 26.6f, 26.5f, 26.4f, 26.3f, 26.2f, 26.3f, 26.3f, 26.4f, 69.5f, 69.4f, 69.3f, 36.1f, 36.1f, 36.2f, 28.9f, 28.9f, 28.8f, 62.4f, 56.2f, 56.3f, 56.4f, 56.5f, 56.6f, 56.5f, 56.5f, 56.5f, 56.6f, 85.4f, 85.3f, 85.2f, 85.1f, 83.21699f, 63.6f, 97.0f, 6.3f, 6.4f, 6.5f, 6.6f, 6.7f, 6.8f, 6.9f, 7.0f, 7.1f, 7.2f, 84.1f, 84.0f, 83.9f, 83.8f, 83.7f, 83.6f, 82.3f, 82.3f, 82.4f, 82.5f, 82.5f, 82.5f, 82.6f, 82.5f, 82.5f, 82.6f, 82.5f, 82.5f, 82.5f, 82.6f, 48.8f, 48.8f, 48.9f, 85.7f, 85.7f, 85.7f, 85.6f, 6.2f, 6.1f, 6.0f, 63.4f, 63.5f, 63.6f, 63.7f, 63.8f, 63.9f, 64.0f, 63.9f, 63.9f, 64.0f, 14.5f, 58.8f, 58.8f, 58.8f, 58.9f, 92.2f, 92.1f, 92.0f, 91.9f, 91.8f, 91.7f, 68.1f, 68.1f, 68.2f, 71.1f, 71.0f, 70.9f, 70.8f, 70.7f, 70.6f, 70.5f, 10.4f, 10.4f, 10.4f, 10.3f, 30.1f, 30.1f, 30.1f, 15.0f, 15.0f, 15.0f, 15.1f, 51.4f, 51.3f, 47.7f, 47.8f, 47.9f, 48.0f, 48.1f, 48.2f, 45.8f, 45.8f, 45.8f, 45.7f, 45.6f, 45.6f, 45.7f, 95.5f, 95.6f, 95.7f, 95.8f, 95.9f, 96.0f, 96.1f, 96.2f, 96.3f, 96.4f, 12.9f, 21.8f, 21.9f, 22.0f, 22.1f, 22.2f, 22.3f, 22.4f, 76.0f, 76.0f, 76.1f, 22.5f, 22.4f, 22.3f, 58.0f, 58.0f, 58.0f, 57.9f, 50.0f, 50.1f, 50.2f, 50.3f, 50.4f, 50.5f, 50.6f, 2.2f, 2.2f, 2.2f, 2.3f, 2.4f, 2.4f, 2.5f, 2.4f, 2.4f, 2.5f, 8.0f, 7.9f, 70.0f, 70.0f, 70.0f, 70.1f, 46.8f, 46.9f, 47.0f, 47.1f, 47.2f, 47.3f, 47.4f, 47.5f, 47.5f, 47.5f, 47.6f, 47.5f, 47.5f, 47.6f, 35.5f, 35.6f, 35.7f, 35.8f, 35.9f, 36.0f, 52.6f, 52.7f, 52.8f, 52.9f, 53.0f, 53.1f, 53.2f, 53.3f, 53.4f, 50.8f, 50.8f, 52.7f, 52.7f, 52.7f, 52.8f, 56.4f, 56.4f, 56.4f, 56.4f, 79.0f, 79.0f, 79.1f, 46.5f, 46.6f, 46.7f, 46.8f, 46.9f, 47.0f, 47.1f, 47.2f, 74.0f, 74.1f, 74.2f, 74.3f, 80.6f, 80.6f, 80.6f, 58.2f, 58.2f, 58.2f, 58.2f, 46.5f, 46.6f, 46.7f, 46.8f, 46.9f, 47.0f, 47.1f, 47.2f, 58.7f, 58.7f, 58.7f, 58.7f, 37.9f, 38.0f, 38.1f, 38.2f, 38.3f, 23.0f, 23.1f, 23.2f, 23.3f, 23.4f, 23.5f, 23.6f, 23.7f, 23.8f, 56.3f, 56.4f, 56.5f, 56.6f, 56.7f, 56.8f, 56.8f, 56.8f, 56.9f, 100.8f, 100.7f, 100.6f, 100.5f, 100.4f, 100.3f, 100.2f, 100.1f, 100.0f, 38.4f, 38.4f, 38.4f, 38.3f, 38.4f, 38.4f, 38.4f, 38.5f, 56.8f, 56.8f, 2.5f, 2.5f, 2.5f, 2.6f, 37.9f, 37.9f, 37.9f, 37.8f, 23.0f, 23.0f, 23.0f, 37.1f, 37.2f, 37.3f, 35.4f, 35.3f, 35.2f, 35.1f, 35.2f, 35.2f, 35.3f, 27.2f, 27.2f, 27.1f, 47.1f, 47.1f, 47.1f, 6.3f, 6.3f, 44.31988f, 44.2f, 44.2f, 44.3f, 89.1f, 89.1f, 89.2f, 89.3f, 89.3f, 89.3f, 89.4f, 47.7f, 47.8f, 88.7f, 88.7f, 88.7f, 88.7f, 4.85531f, 49.2f, 49.1f, 88.3f, 88.4f, 88.5f, 88.6f, 88.7f, 88.8f, 88.9f, 13.8f, 13.9f, 14.0f, 14.1f, 14.2f, 14.3f, 14.4f, 14.5f, 14.6f, 14.5f, 14.5f, 14.6f, 12.0f, 12.0f, 12.0f, 12.1f, 12.0f, 12.0f, 12.1f, 30.2f, 30.2f, 30.2f, 30.3f, 34.7f, 34.7f, 34.6f, 70.8f, 70.9f, 71.0f, 71.1f, 71.2f, 71.3f, 71.4f, 71.5f, 71.6f, 71.7f, 11.3f, 11.3f, 11.3f, 42.4f, 42.4f, 42.5f, 76.7f, 2.8f, 2.8f, 2.7f, 2.7f, 2.8f, 41.4f, 41.5f, 41.6f, 48.5f, 48.5f, 48.6f, 6.7f, 6.6f, 6.5f, 6.4f, 6.3f, 6.2f, 6.1f, 6.0f, 95.11f, 63.2f, 63.2f, 63.1f, 63.0f, 63.0f, 63.1f, 28.15f, 12.5f, 12.6f, 12.7f, 12.8f, 12.9f, 13.0f, 13.1f, 13.2f, 96.12f, 88.8f, 88.7f, 88.6f, 88.6f, 88.6f, 88.7f, 80.2f, 80.2f, 80.2f, 80.1f, 49.5f, 49.5f, 49.5f, 49.5f, 49.4f, 49.4f, 49.5f, 33.2f, 33.2f, 33.2f, 33.1f, 33.0f, 33.0f, 33.1f, 24.0f, 24.0f, 24.0f, 24.0f, 16.7f, 16.7f, 16.8f, 54.323f, 56.20637f, 67.3f, 67.4f, 67.5f, 67.6f, 67.7f, 67.8f, 67.9f, 68.0f, 68.1f, 68.2f, 68.2f, 68.2f, 68.3f, 38.0f, 38.0f, 38.0f, 38.1f, 99.9f, 100.0f, 100.1f, 100.2f, 89.0f, 88.9f, 88.8f, 88.7f, 88.6f, 99.2f, 99.2f
         
         //64.8f, 64.7f, 64.7f, 64.8f, 57.0f, 57.0f, 75.4f, 75.4f, 75.4f  //ok, ticker=ok
         
         //4.7f,4.8f,4.9f,5.0f,5.0f,4.9f  //ok, ticker=ok
         
         //93.7f, 65.0f, 65.1f, 65.1f, 65.2f, 91.4f, 91.4f,5.0f  //ok, ticker=ok
         
         
         //used to resolve issue with chatGPT extract 3 
       //35.0f, 35.1f, 35.1f, 35.2f, 35.1f,  35.1f, 35.1f, 35.2f, 35.1f, 35.1f, 35.1f  //ok, ticker=ok
    //0.9f, 0.9f, 0.9f, 0.9f, 9.5f, 9.4f, 9.4f, 9.5f, 9.6f, 9.6f, 9.6f, 9.7f, 60.1f  //ok, ticker=ok

     //35.0f, 35.1f, 35.1f, 35.2f, 35.1f,  35.1f,35.1f, 35.2f, 35.1f, 35.1f, 35.1f, 35.2f, 21.1f, 21.1f, 21.1f //ok, ticker=ok

    //1.1f, 1.1f, 1.2f, 61.5f, 61.5f, 61.5f, 61.4f, 61.4f, 61.4f, 22.0f, 59.6f, 59.6f //ok, ticker=ok
    
    
    //ChatGPT extract 4 - less variation, but used to ensure my code is functional with an unsed DataSet
    
    /*
    54.2f, 54.2f, 54.2f, 95.3f, 95.3f, 95.3f, 20.37228f, 50.4f, 50.5f, 50.6f, 50.7f, 50.8f, 50.9f, 51.0f, 51.1f, 51.2f, 51.3f, 51.4f, 51.5f, 60.5f, 60.5f, 60.5f, 60.5f, 74.3f, 74.4f, 74.5f, 74.6f, 74.7f, 74.8f, 74.9f, 75.0f, 75.1f, 75.2f, 75.3f, 75.4f, 75.5f, 75.6f, 75.7f, 75.7f, 75.7f, 75.8f, 75.9f, 38.1f, 38.0f, 37.9f, 37.8f, 37.7f, 37.6f, 37.5f, 37.4f, 37.3f, 37.2f, 37.2f, 37.2f, 37.1f, 37.0f, 48.8f, 48.9f, 49.0f, 28.9f, 28.8f, 28.7f, 28.6f, 28.5f, 28.4f, 28.3f, 28.2f, 28.1f, 28.0f, 42.3f, 42.2f, 42.1f, 42.0f, 41.9f, 41.8f, 41.7f, 41.6f, 41.5f, 41.4f, 88.7f, 88.7f, 88.7f, 88.8f, 88.8f, 88.8f, 88.8f, 88.9f, 89.0f, 50.237f, 10.6f, 10.5f, 10.4f, 10.3f, 10.2f, 10.1f, 10.0f, 9.9f, 9.8f, 9.7f, 21.4f, 21.5f, 21.6f, 21.7f, 21.8f, 21.9f, 22.0f, 22.1f, 86.1f, 86.2f, 86.3f, 86.4f, 86.5f, 86.6f, 86.7f, 86.8f, 86.9f, 87.0f, 87.1f, 87.2f, 87.3f, 87.4f, 87.4f, 87.4f, 87.4f, 87.5f, 87.6f, 16.0f, 15.9f, 15.9f, 15.9f, 15.9f, 15.8f, 15.7f, 15.6f, 15.6f, 15.6f, 15.6f, 15.5f, 15.4f, 35.5f, 35.5f, 35.5f, 35.5f, 13.8416f, 13.7f, 13.7f, 13.7f, 13.6f, 13.5f, 6.0f, 63.675f, 20.9f, 21.0f, 21.1f, 21.2f, 21.3f, 21.4f, 21.5f, 90.1f, 90.1f, 90.1f, 12.2f, 12.2f, 48.2f, 48.1f, 48.0f, 47.9f, 47.8f, 47.9f, 47.9f, 47.9f, 47.9f, 48.0f, 48.1f, 48.2f, 48.2f, 48.2f, 48.2f, 48.3f, 48.4f, 7.2f, 7.1f, 7.1f, 7.1f, 7.1f, 7.0f, 6.9f, 6.8f, 6.8f, 6.8f, 6.8f, 6.7f, 6.6f, 26.3f, 26.4f, 86.5f, 86.4f, 51.4f, 51.5f, 51.6f, 51.7f, 51.8f, 51.9f, 52.0f, 52.1f, 52.2f, 52.3f, 52.4f, 52.5f, 52.6f, 52.5f, 52.5f, 52.5f, 52.4f, 52.3f, 6.8f, 6.7f, 6.6f, 6.5f, 6.4f, 6.3f, 6.2f, 6.1f, 34.7f, 34.6f, 34.5f, 34.4f, 34.3f, 34.2f, 34.1f, 34.0f, 33.9f, 33.8f, 33.7f, 94.0f, 94.0f, 94.0f, 15.1f, 15.1f, 15.0f, 15.0f, 14.9f, 14.8f, 14.9f, 14.9f, 14.9f, 15.0f, 15.1f, 88.6f, 88.5f, 88.4f, 88.3f, 88.2f, 88.1f, 88.0f, 87.9f, 87.8f, 35.2f, 35.1f, 35.0f, 31.84553f, 90.04f, 3.0f, 56.7f, 56.6f, 56.5f, 56.4f, 56.3f, 56.2f, 56.1f, 56.0f, 55.9f, 55.8f, 55.9f, 55.9f, 55.9f, 56.0f, 56.1f, 81.4f, 81.3f, 81.2f, 81.1f, 81.0f, 80.9f, 80.8f, 80.7f, 80.6f, 80.5f, 80.4f, 80.3f, 80.2f, 80.1f, 80.0f, 69.5f, 69.6f, 69.7f, 69.8f, 69.9f, 70.0f, 70.1f, 70.2f, 70.3f, 70.4f, 70.5f, 70.6f, 67.4f, 67.4f, 67.4f, 9.0f, 8.9f, 8.8f, 8.7f, 8.6f, 8.5f, 8.4f, 8.3f, 79.7f, 79.7f, 34.21f, 27.0f, 88.73671f, 71.2f, 71.3f, 71.4f, 71.5f, 71.5f, 71.6f, 71.7f, 71.6f, 71.6f, 71.6f, 71.6f, 71.5f, 71.4f, 36.839f, 36.9f, 36.9f, 37.0f, 37.1f, 86.64f, 66.8f, 66.8f, 64.5f, 64.4f, 64.3f, 64.2f, 64.1f, 59.8f, 59.8f, 59.8f, 59.8f, 75.6f, 75.5f, 75.4f, 75.3f, 28.575f, 45.6f, 45.5f, 45.4f, 45.3f, 45.2f, 45.1f, 67.7f, 67.7f, 67.8f, 67.8f, 67.8f, 67.9f, 68.0f, 67.9f, 67.9f, 67.8f, 67.7f, 67.8f, 67.8f, 67.8f, 67.8f, 67.9f, 68.0f, 68.1f, 68.1f, 68.1f, 68.2f, 68.3f, 10.7f, 10.7f, 10.7f, 10.8f, 10.8f, 10.8f, 10.9f, 11.0f, 7.8f, 7.7f, 7.6f, 7.5f, 7.4f, 7.3f, 7.2f, 7.1f, 7.0f, 6.9f, 6.8f, 6.7f, 6.6f, 6.5f, 6.4f, 9.0f, 9.1f, 9.2f, 9.3f, 9.4f, 9.5f, 9.6f, 89.9f, 89.8f, 89.7f, 89.6f, 89.5f, 89.4f, 89.3f, 89.2f, 10.0f, 10.0f, 10.0f, 10.0f, 80.3f, 80.4f, 80.5f, 80.6f, 80.7f, 80.8f, 80.9f, 81.0f, 12.3f, 12.4f, 12.5f, 12.6f, 12.7f, 12.8f, 12.9f, 13.0f, 13.1f, 13.2f, 13.3f, 13.4f, 13.3f, 13.3f, 13.3f, 13.3f, 13.2f, 13.1f, 10.7f, 10.6f, 8.3f, 8.3f, 8.3f, 93.9f, 93.8f, 93.7f, 93.6f, 93.5f, 92.8f, 92.8f, 92.8f, 92.8f, 85.4f, 85.5f, 85.6f, 85.7f, 85.8f, 85.9f, 86.0f, 86.1f, 86.2f, 86.3f, 86.4f, 86.5f, 86.6f, 58.4f, 58.4f, 58.4f, 17.0f, 17.1f, 17.2f, 17.3f, 17.4f, 17.5f, 17.6f, 17.7f, 17.8f, 17.9f, 18.0f, 18.1f, 18.2f, 18.3f, 18.4f, 24.4f, 24.5f, 24.6f, 24.7f, 24.8f, 24.9f, 25.0f, 25.1f, 56.7f, 12.6f, 12.6f, 12.6f, 12.6f, 15.8f, 15.7f, 15.6f, 15.6f, 15.5f, 15.4f, 15.5f, 15.5f, 15.6f, 15.7f, 40.2f, 40.1f, 40.0f, 34.54429f, 94.2f, 94.2f, 18.0f, 27.6f, 27.6f, 27.6f, 27.6f, 27.5f, 27.5f, 27.5f, 27.5f, 27.4f, 27.3f, 90.5f, 90.5f, 90.5f, 90.5f, 22.6f, 22.5f, 36.0f, 31.2f, 31.2f, 31.2f, 31.2f, 96.1f, 96.0f, 95.9f, 95.9f, 95.8f, 95.7f, 74.0f, 85.41326f, 59.7f, 59.6f, 59.5f, 59.4f, 59.3f, 59.2f, 45.405f, 60.462f, 51.2f, 51.1f, 51.0f, 50.9f, 50.8f, 50.7f, 50.7f, 50.7f, 50.7f, 50.6f, 50.5f, 25.9f, 26.0f, 38.5f, 38.5f, 21.3f, 21.4f, 21.5f, 21.6f, 21.7f, 21.8f, 21.9f, 22.0f, 22.1f, 94.61f, 94.69f, 62.615f, 62.5f, 62.5f, 62.4f, 62.3f, 71.43117f, 26.4f, 26.4f, 26.4f, 1.0f, 1.0f, 1.0f, 1.0f, 36.2f, 36.2f, 36.2f, 36.2f, 67.2f, 67.3f, 67.4f, 67.5f, 67.6f, 67.7f, 15.0f, 38.37678f, 74.3f, 74.3f, 74.3f, 74.3f, 0.4f, 0.3f, 0.3f, 0.2f, 0.1f, 74.0f, 98.8f, 98.8f, 98.8f, 98.8f, 99.4f, 99.3f, 99.2f, 99.1f, 99.0f, 98.9f, 98.8f, 98.7f, 98.6f, 98.5f, 98.4f, 98.3f, 98.2f, 98.1f, 10.0f, 10.1f, 10.1f, 10.1f, 10.2f, 10.3f, 29.6f, 29.7f, 29.8f, 29.9f, 30.0f, 81.3f, 81.2f, 93.6f, 37.38207f, 75.79f, 18.3f, 18.2f, 18.1f, 18.0f, 17.9f, 17.8f, 17.7f, 17.6f, 17.5f, 17.4f, 17.3f, 17.2f, 17.1f, 17.0f, 16.9f, 16.9f, 16.9f, 16.9f, 16.8f, 16.7f, 23.1f, 23.0f, 22.9f, 22.8f, 22.7f, 22.6f, 22.5f, 22.4f, 22.3f, 22.2f, 22.1f, 22.0f, 21.9f, 21.8f, 18.04391f, 12.7f, 12.8f, 12.9f, 13.0f, 13.1f, 13.2f, 13.3f, 13.4f, 13.5f, 13.6f, 13.7f, 13.8f, 87.6f, 87.5f, 87.4f, 87.3f, 87.2f, 87.1f, 87.0f, 86.9f, 86.8f, 86.7f, 86.6f, 86.5f, 86.4f, 86.3f, 8.7f, 47.3f, 47.2f, 47.1f, 44.4f, 44.3f, 44.2f, 44.1f, 44.0f, 33.60167f, 33.5f, 33.5f, 33.5f, 33.5f, 33.4f, 33.3f, 26.029f, 48.98958f, 90.2f, 90.1f, 90.0f, 89.9f, 62.8f, 62.8f, 62.8f, 36.3f, 36.4f, 36.5f, 23.4f, 23.3f, 33.1f, 33.0f, 32.9f, 91.92701f, 21.0f, 20.9f, 20.9f, 20.9f, 20.8f, 20.7f, 21.4f, 21.4f, 21.5f, 21.5f, 21.5f, 21.6f, 21.7f, 5.0f, 4.9f, 4.8f, 4.7f, 4.6f, 58.0f, 10.1f, 10.0f, 9.9f, 9.8f, 9.7f, 62.0f, 62.0f, 26.8f, 26.9f, 27.0f, 27.1f, 27.2f, 27.3f, 27.4f, 27.5f, 27.6f, 27.7f, 27.8f, 27.9f, 28.0f, 28.1f, 28.2f, 26.7f, 26.6f, 26.5f, 26.4f, 26.3f, 26.2f, 26.1f, 26.0f, 25.9f, 25.8f, 25.7f, 25.6f, 25.5f, 25.4f, 25.3f, 25.9f, 25.9f, 25.9f, 25.9f, 11.0f, 74.6f, 74.5f, 74.4f, 74.3f, 74.2f, 74.1f, 74.0f, 73.9f, 73.8f, 73.7f, 73.6f, 73.5f, 73.4f, 73.3f, 11.7f, 11.7f, 11.7f, 11.7f, 39.0f, 39.1f, 39.2f, 39.3f, 39.4f, 39.5f, 39.6f, 39.7f, 39.8f, 39.9f, 40.0f, 91.7f, 91.7f, 91.7f, 49.2f, 49.2f, 49.2f, 49.2f, 80.6f, 80.6f, 80.6f, 80.6f, 10.1f, 10.0f, 88.3f, 88.2f, 88.1f, 88.0f, 87.9f, 31.94f, 10.7f, 10.8f, 10.9f, 11.0f, 11.1f, 11.2f, 11.3f, 11.4f, 11.5f, 11.6f, 11.7f, 11.8f, 11.9f, 89.59f, 41.0f, 27.6f, 27.7f, 70.3f, 70.2f, 70.1f, 70.0f, 69.9f, 69.8f, 69.7f, 69.6f, 93.1f, 93.1f, 93.1f, 0.5f, 0.6f, 0.7f, 0.8f, 69.7f, 69.7f, 69.7f, 80.9f, 80.8f, 80.7f, 80.6f, 80.5f, 80.4f, 80.3f, 80.2f, 80.1f, 80.0f, 79.9f, 71.485f, 66.5f, 66.5f, 44.9f, 44.9f, 44.9f, 44.9f, 39.9f, 40.0f, 40.1f, 40.2f, 40.3f, 40.4f, 2.3f, 2.3f, 2.3f, 78.6f, 78.5f, 78.4f, 78.3f, 78.2f, 78.1f, 78.0f, 77.9f, 77.8f, 77.7f, 77.6f, 77.5f, 77.4f, 54.2f, 54.2f, 54.2f, 27.5f, 27.6f, 27.7f, 27.8f, 27.9f, 28.0f, 28.1f, 28.2f, 28.3f, 28.4f, 28.5f, 28.6f, 28.7f, 28.8f, 28.9f, 18.6f, 18.6f, 18.6f, 18.6f, 80.0f, 7.2f, 7.1f, 7.0f, 6.9f, 6.8f, 6.7f, 6.6f, 6.5f, 6.4f, 6.3f, 6.2f, 6.1f, 6.0f, 5.9f, 5.8f, 52.0f, 52.1f, 52.2f, 52.3f, 52.4f, 52.5f, 1.1f, 1.0f, 0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 93.4f, 93.3f, 93.2f, 93.1f, 93.0f, 92.9f, 92.8f, 92.7f, 92.6f, 92.5f, 84.9f, 84.9f, 84.9f, 84.9f, 88.89f, 52.0f, 51.9f, 51.9f, 51.9f, 51.9f, 51.8f, 51.7f, 34.8f, 17.0f, 17.1f, 17.2f, 17.3f, 17.2f, 17.2f, 17.2f, 17.1f, 17.0f, 66.0f, 66.1f, 66.2f, 66.3f, 66.4f, 66.5f, 66.6f, 66.7f, 66.8f, 66.9f, 67.0f, 67.1f, 67.2f, 82.5f, 82.6f, 82.7f, 82.8f, 82.9f, 83.0f, 83.1f, 83.2f, 83.3f, 83.4f, 83.5f, 83.6f, 83.6f, 83.6f, 83.7f, 83.8f, 83.9f, 83.9f, 83.9f, 83.9f, 84.0f, 84.1f, 85.0f, 85.1f, 85.2f, 85.3f, 85.4f, 85.5f, 48.8f, 48.9f, 49.0f, 49.1f, 96.6f, 96.7f, 96.8f, 96.9f, 97.0f, 97.1f, 97.2f, 97.3f, 97.4f, 97.5f, 97.6f, 97.7f, 97.8f, 97.9f, 98.0f, 79.0f, 79.0f, 30.0f, 29.9f, 29.8f, 29.7f, 29.7f, 29.7f, 29.6f, 29.5f, 29.4f, 29.4f, 29.4f, 29.3f, 29.2f, 29.1f, 29.1f, 29.0f, 28.9f, 99.0f, 29.27f, 41.45097f, 25.05961f, 20.3f, 20.2f, 20.1f, 20.0f, 19.9f, 19.8f, 19.7f, 19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.1f, 19.0f, 19.0f, 19.0f, 18.9f, 18.8f, 10.3f, 10.4f, 10.5f, 10.6f, 10.7f, 10.8f, 10.9f, 11.0f, 50.0f, 54.5f, 54.5f, 54.5f, 59.1f, 59.1f, 59.1f, 59.1f, 59.0f, 59.0f, 59.0f, 59.0f, 58.9f, 58.8f, 58.7f, 58.7f, 58.7f, 58.6f, 58.5f, 66.9f, 66.8f, 66.7f, 66.6f, 66.5f, 66.4f, 66.3f, 66.2f, 66.1f, 66.1f, 66.1f, 66.0f, 65.9f, 52.7f, 52.7f, 52.7f, 52.8f, 52.8f, 52.9f, 53.0f, 20.5f, 20.4f, 20.3f, 20.2f, 20.1f, 20.0f, 74.89413f, 88.5f, 88.4f, 88.3f, 88.2f, 88.1f, 88.0f, 87.9f, 87.8f, 6.2f, 6.3f, 6.4f, 6.5f, 6.6f, 6.7f, 32.7f, 32.8f, 32.9f, 33.0f, 33.1f, 33.2f, 33.3f, 33.4f, 33.5f, 33.6f, 33.7f, 33.8f, 33.9f, 34.0f, 28.5f, 28.6f, 28.7f, 28.8f, 28.9f, 53.6f, 53.6f, 88.5f, 88.5f, 16.1f, 16.2f, 16.3f, 16.4f, 16.5f, 16.6f, 16.7f, 16.8f, 16.9f, 17.0f, 17.1f, 17.2f, 57.2f, 57.3f, 57.4f, 57.5f, 4.7f, 4.6f, 4.5f, 4.4f, 4.3f, 4.2f, 4.1f, 4.0f, 3.9f, 3.8f, 3.9f, 3.9f, 4.0f, 4.1f, 49.8f, 49.7f, 49.6f, 49.5f, 49.4f, 49.3f, 49.2f, 49.1f, 49.0f, 48.9f, 48.8f, 48.7f, 48.6f, 48.5f, 56.0f, 56.0f, 56.0f, 13.1f, 13.0f, 13.1f, 13.1f, 13.1f, 13.1f, 13.2f, 13.3f, 42.5f, 42.4f, 42.3f, 42.2f, 42.1f, 42.0f, 41.9f, 41.8f, 41.7f, 41.6f, 41.5f, 41.4f, 52.8f, 52.8f, 60.454f, 60.6f, 60.6f, 60.6f, 60.7f, 60.8f, 60.9f, 60.9f, 61.0f, 61.1f, 61.2f, 61.2f, 61.2f, 61.2f, 61.3f, 61.4f, 57.8f, 57.7f, 57.6f, 57.5f, 57.4f, 57.3f, 57.2f, 57.1f, 61.0f, 2.1f, 91.9f, 91.8f, 91.7f, 91.7f, 91.7f, 91.7f, 91.7f, 14.24901f, 26.1f, 26.0f, 25.9f, 25.8f, 25.7f, 25.6f, 25.5f, 25.4f, 25.3f, 25.2f, 25.1f, 17.79f, 2.0f, 42.1f, 42.2f, 42.3f, 52.0f, 51.9f, 51.8f, 51.7f, 51.6f, 51.5f, 51.4f, 51.3f, 51.4f, 51.4f, 51.4f, 51.4f, 51.5f, 51.6f, 24.9f, 25.0f, 25.1f, 25.2f, 25.3f, 25.4f, 25.5f, 25.6f, 25.7f, 25.8f, 56.6f, 56.5f, 56.4f, 56.3f, 56.2f, 56.1f, 56.0f, 55.9f, 55.8f, 55.7f, 55.6f, 55.5f, 64.5f, 64.6f, 64.7f, 71.2f, 71.1f, 71.0f, 70.9f, 70.8f, 70.7f, 70.6f, 70.5f, 70.4f, 52.7f, 52.7f, 52.7f, 52.7f, 66.6f, 5.8f, 5.9f, 6.0f, 6.1f, 6.2f, 6.3f, 6.4f, 6.5f, 6.6f, 6.7f, 6.8f, 6.7f, 6.7f, 6.6f, 6.5f, 35.2f, 52.7f, 52.8f, 52.9f, 53.0f, 53.1f, 53.2f, 53.3f, 53.4f, 53.5f, 74.0f, 96.7f, 96.6f, 96.5f, 96.4f, 96.3f, 96.2f, 96.1f, 96.0f, 95.9f, 95.8f, 95.7f, 95.6f, 95.5f, 95.4f, 95.5f, 95.5f, 95.5f, 95.6f, 95.7f, 95.6f, 95.6f, 95.6f, 95.6f, 95.5f, 95.4f, 18.1f, 18.0f, 17.9f, 17.8f, 17.7f, 17.6f, 17.5f, 17.4f, 17.3f, 17.2f, 17.1f, 17.0f, 16.9f, 17.0f, 17.0f, 17.0f, 17.1f, 17.2f, 17.3f, 17.3f, 17.4f, 17.5f, 17.4f, 17.4f, 17.4f, 17.4f, 17.3f, 17.2f, 52.419f, 32.6f, 32.5f, 32.4f, 32.3f, 32.2f, 32.1f, 32.0f, 31.9f, 31.8f, 31.7f, 31.6f, 31.5f, 31.4f, 31.3f, 31.3f, 31.2f, 31.1f, 45.8f, 45.8f, 45.8f, 45.8f, 45.9f, 45.9f, 45.9f, 46.0f, 46.1f, 27.3f, 27.3f, 27.3f, 27.3f, 8.6f, 8.7f, 8.8f, 8.9f, 9.0f, 9.1f, 9.2f, 9.3f, 9.4f, 18.0f, 17.9f, 17.9f, 17.9f, 17.8f, 17.7f, 87.7f, 48.4f, 48.5f, 48.6f, 48.7f, 48.8f, 48.9f, 49.0f, 49.1f, 49.2f, 49.3f, 49.4f, 49.5f, 49.6f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.6f, 1.6f, 1.6f, 1.7f, 1.8f, 26.0f, 26.1f, 26.2f, 26.3f, 56.4f, 56.3f, 56.2f, 56.1f, 56.0f, 55.9f, 55.8f, 55.7f, 55.6f, 55.5f, 21.2f, 21.2f, 21.2f, 21.3f, 21.3f, 21.3f, 21.3f, 21.4f, 21.5f, 10.2f, 10.2f, 10.2f, 10.2f, 74.6f, 74.7f, 74.8f, 63.6f, 63.5f, 63.4f, 63.3f, 63.2f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.6f, 1.7f, 1.8f, 1.7f, 1.7f, 1.7f, 1.6f, 1.5f, 16.2f, 16.1f, 16.0f, 15.9f, 15.8f, 15.7f, 15.6f, 15.5f, 15.4f, 15.3f, 15.4f, 15.4f, 15.4f, 15.5f, 15.6f, 98.137f, 31.7f, 31.7f, 31.7f, 31.7f, 85.1f, 85.2f, 85.3f, 44.21652f, 47.25248f, 97.2f, 97.3f, 97.4f, 97.5f, 97.6f, 97.7f, 97.8f, 97.9f, 6.6f, 6.7f, 6.8f, 6.9f, 7.0f, 7.1f, 7.1f, 7.1f, 7.1f, 7.2f, 7.3f, 7.2f, 7.2f, 7.2f, 7.1f, 7.0f, 37.3f, 37.3f, 37.3f, 37.3f, 93.2f, 93.1f, 93.0f, 92.9f, 92.8f, 92.7f, 92.6f, 92.5f, 69.3f, 69.3f, 69.3f, 69.3f, 27.0f, 27.0f, 21.4f, 21.4f, 21.4f, 21.4f, 55.2f, 55.3f, 55.4f, 55.5f, 55.6f, 55.6f, 55.7f, 55.8f, 55.9f, 55.9f, 56.0f, 56.1f, 56.2f, 56.2f, 56.2f, 56.2f, 56.3f, 56.4f, 63.4f, 63.3f, 63.2f, 63.1f, 63.0f, 62.9f, 62.8f, 62.7f, 62.6f, 62.5f, 62.4f, 62.3f, 62.2f, 62.1f, 62.0f, 62.0f, 62.0f, 62.0f, 61.9f, 61.8f, 9.3f, 46.5f, 52.0f, 52.1f, 52.2f, 52.3f, 52.4f, 52.5f, 52.6f, 52.7f, 52.8f, 52.9f, 53.0f, 53.1f, 53.0f, 53.0f, 52.9f, 52.8f, 52.9f, 52.9f, 52.9f, 52.9f, 53.0f, 53.1f, 53.2f, 53.2f, 53.3f, 53.4f, 13.9f, 13.9f, 91.2f, 91.1f, 91.0f, 90.9f, 90.8f, 90.7f, 90.6f, 61.2f, 61.2f, 61.2f, 61.1f, 61.1f, 61.1f, 61.0f, 60.9f, 99.64f, 57.9f, 58.0f, 58.1f, 58.2f, 58.3f, 58.4f, 58.5f, 58.6f, 58.7f, 58.8f, 58.9f, 59.0f, 59.1f, 72.8f, 72.9f, 73.0f, 73.1f, 73.2f, 73.3f, 73.4f, 73.5f, 73.6f, 73.7f, 73.8f, 35.13f, 31.9f, 32.0f, 32.1f, 32.2f, 32.3f, 32.4f, 32.5f, 32.6f, 32.7f, 32.8f, 32.9f, 25.7f, 25.6f, 25.5f, 25.4f, 25.3f, 25.2f, 25.1f, 25.0f, 24.9f, 24.8f, 24.7f, 24.6f, 24.5f, 37.2f, 37.2f, 37.2f, 37.2f, 16.7f, 16.7f, 9.5f, 9.5f, 99.1f, 99.2f, 99.3f, 93.9f, 93.9f, 93.9f, 42.3f, 42.4f, 39.4f, 39.4f, 96.5f, 96.4f, 96.3f, 96.2f, 96.1f, 96.0f, 95.9f, 24.3f, 24.3f, 8.6f, 8.7f, 8.8f, 8.9f, 9.0f, 9.1f, 9.2f, 9.3f, 9.4f, 9.5f, 9.6f, 9.7f, 9.8f, 9.9f, 9.9f, 9.9f, 10.0f, 10.1f, 10.0f, 10.0f, 10.0f, 9.9f, 9.8f, 56.8f, 56.9f, 57.0f, 57.1f, 57.2f, 57.3f, 57.4f, 57.5f, 57.6f, 57.7f, 57.8f, 15.7f, 15.7f, 15.8f, 15.8f, 15.8f, 15.9f, 16.0f, 78.795f, 84.6f, 84.6f, 84.6f, 34.114f, 75.4f, 75.3f, 75.2f, 75.1f, 75.0f, 74.9f, 74.8f, 74.7f, 74.6f, 74.5f, 74.4f, 97.2f, 97.2f, 97.2f, 97.2f, 58.12869f, 85.9f, 85.8f, 85.7f, 85.6f, 85.5f, 85.4f, 85.3f, 85.2f, 85.1f, 85.0f, 84.9f, 84.8f, 84.7f, 84.6f, 84.5f, 27.7f, 27.6f, 27.5f, 27.4f, 27.3f, 27.2f, 27.1f, 27.0f, 26.9f, 26.8f, 26.7f, 26.6f, 26.5f, 26.4f, 7.6f, 7.5f, 7.4f, 7.3f, 7.2f, 7.1f, 11.4f, 11.4f, 11.4f, 11.4f, 65.7f, 10.5f, 26.50572f, 41.2f, 41.2f, 41.2f, 39.7f, 39.7f, 39.7f, 24.9f, 24.9f, 83.6f, 83.7f, 83.8f, 83.9f, 84.0f, 84.1f, 49.416f, 49.5f, 49.5f, 49.5f, 49.5f, 49.6f, 49.7f, 54.8f, 54.9f, 55.0f, 55.1f, 55.2f, 55.3f, 55.4f, 55.5f, 55.6f, 41.0f, 41.0f, 41.0f, 41.0f, 8.1f, 8.0f, 7.9f, 7.8f, 7.7f, 7.6f, 7.5f, 7.4f, 7.3f, 7.2f, 7.1f, 7.0f, 6.9f, 6.8f, 6.7f, 6.8f, 6.8f, 6.8f, 6.8f, 6.9f, 7.0f, 15.6f, 15.7f, 66.0f, 66.1f, 66.2f, 66.3f, 66.4f, 66.5f, 66.6f, 66.7f, 66.8f, 66.7f, 66.7f, 66.7f, 66.6f, 66.5f, 58.2f, 58.2f, 58.2f, 58.3f, 58.3f, 58.3f, 58.4f, 58.5f, 58.4f, 58.4f, 58.3f, 58.2f, 31.1f, 31.0f, 30.9f, 30.8f, 30.7f, 30.6f, 30.5f, 30.4f, 30.3f, 30.2f, 30.1f, 30.0f, 29.9f, 49.1f, 49.2f, 49.3f, 49.4f, 49.5f, 99.9f, 94.0f, 94.0f, 94.0f, 91.9f, 91.8f, 91.7f, 91.6f, 91.5f, 82.5f, 70.47f, 71.779f, 88.474f, 69.227f, 46.476f, 50.4f, 50.3f, 50.2f, 50.1f, 50.0f, 49.9f, 49.8f, 49.7f, 49.6f, 49.5f, 49.4f, 49.3f, 49.2f, 5.1f, 5.1f, 5.1f, 9.21f, 90.1f, 90.1f, 90.1f, 4.9f, 4.9f, 73.6f, 73.7f, 73.8f, 73.9f, 74.0f, 74.1f, 19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.1f, 19.0f, 18.9f, 18.8f, 18.7f, 18.6f, 18.5f, 18.4f, 18.3f, 18.2f, 76.9f, 76.8f, 76.7f, 76.6f, 76.5f, 76.4f, 76.3f, 76.2f, 76.1f, 13.0f, 13.1f, 13.2f, 13.3f, 13.4f, 13.5f, 13.6f, 13.7f, 13.8f, 3.8f, 3.9f, 4.0f, 4.1f, 4.2f, 4.3f, 4.2f, 4.2f, 4.1f, 4.0f, 74.7f, 74.8f, 74.9f, 75.0f, 76.7f, 76.6f, 76.5f, 76.4f, 76.3f, 76.2f, 76.1f, 76.0f, 75.9f, 75.8f, 75.7f, 75.6f, 75.5f, 46.6f, 46.7f, 46.8f, 46.9f, 47.0f, 47.1f, 47.2f, 47.3f, 47.4f, 47.5f, 84.1f, 84.1f, 74.1f, 74.1f, 74.1f, 74.1f, 76.3f, 76.4f, 76.5f, 76.6f, 76.7f, 76.8f, 76.9f, 77.0f, 77.1f, 77.2f, 77.3f, 77.4f, 77.5f, 77.4f, 77.4f, 77.3f, 77.2f, 77.3f, 77.3f, 77.4f, 77.5f, 54.9f, 54.8f, 54.7f, 54.6f, 54.5f, 80.3f, 80.2f, 80.1f, 80.0f, 79.9f, 79.8f, 79.7f, 79.6f, 79.5f, 79.4f, 79.3f, 79.2f, 46.0f, 70.7f, 70.7f, 70.8f, 70.8f, 70.8f, 70.8f, 70.9f, 71.0f, 50.0f, 50.1f, 50.2f, 50.3f, 50.4f, 50.5f, 50.6f, 50.7f, 50.8f, 50.9f, 51.0f, 51.1f, 5.1f, 5.0f, 4.9f, 4.8f, 4.7f, 4.6f, 4.5f, 36.5f, 36.4f, 36.3f, 36.2f, 36.1f, 36.0f, 35.9f, 35.8f, 35.7f, 35.6f, 35.5f, 35.4f, 92.4f, 92.5f, 92.6f, 92.7f, 92.8f, 92.9f, 93.0f, 93.1f, 93.2f, 93.3f, 93.4f, 93.5f, 93.4f, 93.4f, 93.4f, 93.4f, 93.3f, 93.2f, 46.0f, 45.9f, 45.8f, 45.7f, 45.6f, 45.5f, 45.4f, 45.3f, 45.2f, 45.1f, 45.0f, 44.9f, 44.8f, 44.7f, 44.6f, 44.7f, 44.7f, 44.7f, 44.7f, 44.8f, 44.9f, 80.7f, 80.6f, 80.5f, 80.4f, 80.3f, 80.2f, 80.1f, 80.0f, 79.9f, 79.8f, 79.7f, 79.6f, 79.5f, 52.9f, 52.8f, 52.7f, 52.6f, 52.5f, 52.4f, 52.3f, 52.2f, 52.1f, 52.0f, 51.9f, 51.8f, 51.7f, 51.6f, 82.521f, 97.8f, 97.9f, 98.0f, 98.1f, 98.2f, 98.3f, 98.4f, 95.1f, 95.2f, 95.3f, 95.4f, 78.3f, 78.3f, 78.3f, 78.3f, 60.7f, 60.6f, 60.5f, 60.4f, 60.3f, 60.2f, 60.1f, 60.0f, 59.9f, 91.8f, 91.8f, 91.8f, 91.8f, 33.2f, 33.3f, 33.4f, 33.5f, 33.6f, 33.7f, 33.8f, 33.9f, 34.0f, 34.1f, 34.2f, 34.3f, 55.8f, 55.8f, 55.8f, 36.11f, 67.9f, 68.0f, 68.1f, 68.2f, 68.3f, 68.4f, 68.5f, 68.6f, 96.4f, 96.3f, 96.2f, 96.1f, 96.0f, 86.8f, 86.8f, 99.05f, 32.8f, 32.9f, 33.0f, 33.1f, 33.2f, 33.3f, 33.4f, 33.5f, 33.6f, 33.7f, 33.8f, 33.9f, 34.0f, 34.1f, 34.2f, 4.7f, 4.6f, 4.5f, 4.4f, 4.3f, 4.2f, 4.1f, 4.0f, 3.9f, 3.8f, 3.7f, 3.6f, 3.5f, 3.4f, 23.9f, 23.8f, 23.7f, 23.6f, 23.5f, 23.4f, 23.3f, 23.2f, 23.1f, 21.9f, 21.8f, 21.7f, 21.6f, 13.6f, 13.7f, 13.8f, 13.9f, 14.0f, 14.1f, 14.2f, 14.3f, 14.4f, 14.5f, 14.6f, 14.7f, 14.8f, 14.9f, 13.8f, 13.9f, 14.0f, 14.1f, 14.2f, 14.3f, 14.4f, 14.5f, 14.6f, 14.7f, 14.8f, 14.9f, 36.3f, 36.3f, 85.4f, 85.5f, 85.6f, 85.7f, 84.0f, 83.9f, 83.8f, 83.7f, 83.6f, 83.5f, 83.4f, 83.3f, 83.2f, 83.1f, 83.0f, 96.83f, 7.1f, 83.8f, 83.9f, 84.0f, 84.1f, 84.2f, 84.3f, 84.4f, 84.5f, 84.6f, 84.7f, 84.8f, 84.9f, 85.0f, 19.7f, 19.7f, 19.7f, 19.7f, 11.0f, 65.3f, 65.4f, 65.5f, 65.6f, 65.7f, 65.8f, 65.9f, 42.5f, 42.6f, 42.7f, 42.8f, 42.9f, 43.0f, 43.1f, 43.2f, 43.3f, 57.27f, 57.2f, 57.2f, 57.2f, 57.1f, 57.0f, 15.3f, 15.3f, 15.3f, 57.94f, 2.27693f, 38.7f, 38.8f, 38.9f, 39.0f, 39.1f, 39.2f, 39.3f, 39.4f, 39.5f, 39.6f, 39.7f, 39.8f, 39.9f, 40.0f, 40.0f, 40.0f, 40.1f, 40.2f, 91.6f, 87.1f, 87.0f, 86.9f, 86.8f, 86.7f, 86.6f, 86.5f, 86.4f, 86.3f, 86.2f, 86.1f, 86.0f, 85.9f, 85.8f, 78.7f, 78.7f, 78.7f, 71.1f, 71.1f, 71.1f, 4.3f, 4.2f, 4.1f, 4.0f, 3.9f, 3.8f, 3.7f, 3.6f, 3.5f, 56.7f, 56.8f, 56.9f, 57.0f, 57.1f, 57.2f, 57.3f, 57.4f, 13.8f, 13.9f, 14.0f, 14.1f, 14.2f, 14.3f, 14.4f, 14.5f, 14.6f, 14.7f, 14.8f, 14.9f, 15.0f, 10.2f, 10.2f, 10.2f, 28.6f, 28.6f, 28.6f, 28.6f, 2.9f, 2.8f, 97.2f, 97.2f, 97.2f, 97.2f, 62.4f, 62.4f, 62.4f, 62.4f, 62.3f, 62.3f, 62.3f, 62.3f, 62.2f, 62.1f, 38.0f, 38.1f, 38.2f, 38.3f, 38.4f, 38.5f, 38.6f, 38.7f, 38.8f, 38.9f, 39.0f, 39.1f, 39.2f, 39.3f, 26.8f, 26.7f, 26.6f, 26.5f, 26.4f, 26.3f, 26.2f, 26.1f, 26.0f, 54.6f, 54.6f, 54.5f, 54.5f, 54.5f, 54.5f, 54.4f, 54.3f, 96.9f, 97.0f, 97.1f, 11.06f, 11.0f, 11.0f, 11.0f, 10.9f, 10.8f, 79.982f, 87.0f, 86.9f, 86.9f, 86.9f, 86.8f, 86.7f, 26.2856f, 26.2f, 26.2f, 26.1f, 26.0f, 40.8f, 40.7f, 40.6f, 40.5f, 40.4f, 40.3f, 40.2f, 40.1f, 40.0f, 78.6f, 78.5f, 78.4f, 78.3f, 78.2f, 78.1f, 8.6f, 8.5f, 8.4f, 8.3f, 8.2f, 8.1f, 8.0f, 7.9f, 8.9f, 8.8f, 8.7f, 8.6f, 8.5f, 8.4f, 8.3f, 8.2f, 8.1f, 8.0f, 7.9f, 7.8f, 53.0f, 38.6f, 46.2f, 46.2f, 46.2f, 94.0f, 94.1f, 94.2f, 94.3f, 94.4f, 44.0f, 43.9f, 43.8f, 43.7f, 43.6f, 43.5f, 43.4f, 43.3f, 43.2f, 75.4f, 75.4f, 75.4f, 75.4f, 98.5f, 98.6f, 98.7f, 98.8f, 98.9f, 99.0f, 99.1f, 99.2f, 99.3f, 19.8f, 19.7f, 19.6f, 19.5f, 19.4f, 19.3f, 52.8f, 52.7f, 52.6f, 52.5f, 52.4f, 52.3f, 52.2f, 52.1f, 52.0f, 51.9f, 51.8f, 51.7f, 51.6f, 79.0f, 79.1f, 79.2f, 79.3f, 79.4f, 12.16405f, 49.1f, 49.1f, 22.0f, 19.0f, 3.5f, 3.4f, 3.3f, 3.2f, 3.1f, 3.0f, 2.9f, 2.8f, 2.7f, 89.47925f, 3.4f, 3.3f, 36.6f, 36.7f, 36.8f, 36.9f, 37.0f, 70.7747f, 25.1f, 25.2f, 25.3f, 25.4f, 25.5f, 25.6f, 25.7f, 25.8f, 25.9f, 26.0f, 26.1f, 26.2f, 26.3f, 26.4f, 26.5f, 12.9f, 12.9f, 95.0f, 95.1f, 95.1f, 95.1f, 95.1f, 95.2f, 95.3f, 75.6f, 75.7f, 75.8f, 75.9f, 76.0f, 76.1f, 76.2f, 76.3f, 76.4f, 76.5f, 76.6f, 76.7f, 76.8f, 13.448f, 34.2f, 34.3f, 34.3f, 34.3f, 34.3f, 34.4f, 34.5f, 62.7f, 62.6f, 62.5f, 62.4f, 62.3f, 62.2f, 62.1f, 62.0f, 61.9f, 61.8f, 61.7f, 61.6f, 77.5f, 77.5f, 77.5f, 72.7f, 72.6f, 72.5f, 72.4f, 72.3f, 72.2f, 10.5f, 99.0f, 99.1f, 99.2f, 99.3f, 99.4f, 99.5f, 99.6f, 58.2f, 58.1f, 58.0f, 57.9f, 57.8f, 57.7f, 57.6f, 57.5f, 57.4f, 57.3f, 57.2f, 57.1f, 57.0f, 56.9f, 56.8f, 56.8f, 56.8f, 56.8f, 56.7f, 56.6f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 38.4f, 38.5f, 38.6f, 38.7f, 38.8f, 38.9f, 38.8f, 38.8f, 38.8f, 38.8f, 38.7f, 38.6f, 81.9f, 81.8f, 81.7f, 72.96708f, 40.8f, 40.8f, 40.8f, 40.8f, 83.23453f, 83.3f, 83.3f, 83.3f, 83.4f, 83.5f, 0.4f, 0.4f, 0.4f, 0.4f, 49.3f, 49.3f, 49.3f, 49.4f, 49.4f, 49.4f, 49.4f, 49.5f, 49.6f, 31.35748f, 100.9f, 100.8f, 100.7f, 100.6f, 100.5f, 100.4f, 100.3f, 100.2f, 100.1f, 100.0f, 99.9f, 99.8f, 99.7f, 99.6f, 99.5f, 98.7f, 98.7f, 98.7f, 98.7f, 27.1f, 27.0f, 26.9f, 26.8f, 26.7f, 26.6f, 59.6f, 59.5f, 59.4f, 59.3f, 59.2f, 59.1f, 59.0f, 58.9f, 58.8f, 58.7f, 58.6f, 58.5f, 58.4f, 58.3f, 29.5f, 29.6f, 29.7f, 29.8f, 29.9f, 57.8f, 57.7f, 57.6f, 57.5f, 57.4f, 57.3f, 57.2f, 57.1f, 57.0f, 56.9f, 56.8f, 70.4f, 70.3f, 71.7f, 71.6f, 71.5f, 71.4f, 71.3f, 71.2f, 39.3f, 39.4f, 39.5f, 39.6f, 39.7f, 39.8f, 39.9f, 40.0f, 40.1f, 40.2f, 40.3f, 40.4f, 67.3f, 67.2f, 67.1f, 67.0f, 66.9f, 8.5f, 8.4f, 8.3f, 8.2f, 8.1f, 8.0f, 7.9f, 7.8f, 7.7f, 7.6f, 7.5f, 7.4f, 7.3f, 63.31805f, 98.6f, 98.5f, 98.4f, 98.3f, 98.2f, 98.1f, 98.0f, 97.9f, 97.8f, 97.7f, 97.6f, 97.5f, 97.4f, 97.3f, 97.2f, 74.4f, 74.5f, 74.6f, 75.0f, 74.9f, 74.8f, 74.7f, 74.6f, 74.5f
    */
    
    //other tests
    //6.8f, 6.7f, 6.6f,26.3f, 26.4f, 86.5f, 86.4f, 51.4f,	51.5f,51.6f,51.7f,51.8f,51.9f,52.0f  //ok, ticker=ok
    //52.1f, 52.2f, 52.3f,52.4f, 52.5f, 52.6f, 52.5f  //ok, ticker=ok
    //45.0f,44.9f,44.8f,44.7f,30.0f,29.9f,29.8f,34.0f,34.1f,34.2f,34.3f,34.4f,34.3f  //ok, ticker=ok
    
    //ChatGPT extract 5
    //80.206f, 80.308f, 80.409f, 80.508f, 80.607f, 80.708f, 80.809f, 80.903f, 81.009f, 2.5f,2.6f, 2.7f, 88.5f, 88.5f, 88.5f, 88.5f, 88.5f, 88.5f, 39.0f, 39.0f,39.0f, 67.3f, 67.3f, 67.3f, 8.2f, 8.3f, 8.4f, 8.5f, 8.6f, 8.7f,8.8f, 8.9f, 9.0f, 8.9f, 15.3f, 22.2f, 96.607f, 96.613f, 46.2f, 46.3f,46.4f, 9.0f, 9.1f, 9.2f, 9.3f, 45.8f, 45.7f, 45.6f, 45.5f, 45.4f,45.3f, 45.2f, 45.1f, 26.1f, 26.2f, 26.3f, 4.1f, 4.0f, 3.9f, 3.8f,3.7f, 3.6f, 3.5f, 3.4f, 3.3f, 3.404f, 3.409f, 38.104f, 38.106f, 81.5f,12.7f, 12.7f, 12.7f, 12.705f, 12.712f, 12.720f, 15.3f, 15.4f, 15.5f, 15.6f,15.7f, 15.8f, 13.8f, 13.7f, 13.6f, 13.5f, 48.603f, 48.705f, 48.806f, 48.906f,49.001f, 49.105f, 49.205f, 49.308f, 71.3f, 71.4f, 71.5f, 71.6f, 71.7f, 71.8f,71.9f, 72.0f, 65.1f, 65.0f, 64.9f, 92.0f, 92.0f, 94.1f, 94.1f, 94.1f,94.1f, 9.5f, 9.6f, 9.7f, 9.8f, 9.9f, 26.1f, 26.0f, 25.9f, 25.8f,25.7f, 25.6f, 25.5f, 25.4f, 81.8f, 81.9f, 82.0f, 82.1f, 82.2f, 82.3f,82.4f, 82.5f, 82.6f, 95.7f, 63.6f, 63.7f, 63.8f, 63.9f, 64.0f, 64.1f,64.2f, 64.3f, 9.2f, 9.2f, 36.9f, 37.0f, 36.9f, 36.9f, 36.9f, 79.4f,79.4f, 79.4f, 81.1f, 81.2f, 81.3f, 81.4f, 81.3f, 70.6f, 70.7f, 70.8f,70.8f, 70.8f, 70.8f, 70.8f, 70.8f, 70.8f, 70.8f, 70.8f, 70.8f, 70.8f,23.9f, 23.8f, 23.7f, 23.6f, 23.5f, 23.4f, 12.203f, 12.101f, 12.005f, 11.908f,11.804f, 11.706f, 11.602f, 11.508f, 11.602f, 69.2f, 69.1f, 69.2f, 69.2f, 69.2f,69.2f, 69.2f, 23.1f, 23.0f, 22.9f, 22.8f, 22.7f, 36.3f, 36.3f, 36.3f,36.3f, 36.3f, 36.3f, 36.3f, 73.8f, 12.0f, 51.308f, 51.407f, 51.507f, 51.604f,51.706f, 29.9f, 30.0f, 30.1f, 30.2f, 30.3f, 30.4f, 30.5f, 30.6f, 11.3f,40.5f, 40.4f, 40.3f, 40.2f, 40.1f, 40.0f, 40.0f, 40.0f, 40.0f, 35.0f,91.2f, 91.3f, 91.4f, 91.5f, 98.3f, 98.2f, 98.1f, 98.0f, 97.9f, 97.8f,97.7f, 45.202f, 45.301f, 45.407f, 45.503f, 45.605f, 45.708f, 45.804f, 45.804f, 45.804f,65.3f, 65.2f, 65.1f, 65.0f, 64.9f, 64.8f, 64.7f, 64.6f, 64.5f, 71.106f,22.1f, 22.2f, 22.3f, 22.4f, 22.5f, 22.6f, 22.7f, 37.506f, 37.605f, 37.704f,72.6f, 72.5f, 72.4f, 72.3f, 72.2f, 8.9f, 9.0f, 9.1f, 9.2f, 9.3f,9.4f, 9.5f, 9.6f, 9.7f, 68.2f, 68.1f, 68.0f, 67.9f, 77.0f, 77.1f,77.2f, 58.7f, 9.2f, 9.1f, 9.0f, 9.0f, 9.0f, 9.0f, 12.6f, 95.7f,95.7f, 83.1f, 83.2f, 83.3f, 83.4f, 83.5f, 83.6f, 83.7f, 9.2f, 81.4f,81.3f, 81.2f, 81.1f, 81.1f, 66.2f, 66.3f, 66.4f, 66.5f, 66.6f, 66.7f,66.8f, 12.3f, 12.4f, 12.5f, 12.6f, 12.7f, 24.6f, 24.5f, 24.4f, 24.3f,53.3f, 24.3f, 55.2f, 35.5f, 35.4f, 35.3f, 35.2f, 35.1f, 35.0f, 34.9f,34.8f, 98.8f, 98.9f, 99.0f, 99.1f, 99.2f, 99.3f, 99.4f, 99.5f, 99.6f,3.1f, 3.2f, 3.3f, 86.7f, 37.0f, 36.9f, 36.8f, 36.7f, 36.6f, 36.5f,36.4f, 36.3f, 36.2f, 20.7f, 20.6f, 20.5f, 20.4f, 20.5f, 81.6f, 81.5f,81.4f, 81.5f, 81.5f, 81.5f, 81.5f, 81.4f, 81.3f, 59.3f, 59.3f, 80.6f,80.5f, 80.4f, 80.3f, 80.2f, 80.1f, 80.0f, 83.5f, 83.6f, 83.7f, 83.8f,83.9f, 84.0f, 84.1f, 84.2f, 84.3f, 80.6f, 80.5f, 80.4f, 80.5f, 80.5f,80.5f, 80.5f, 80.5f, 80.5f, 7.8f, 7.7f, 7.6f, 7.5f, 7.6f, 7.6f,92.3f, 92.2f, 92.1f, 92.0f, 91.9f, 91.8f, 91.7f, 91.6f, 91.7f, 91.7f,47.9f, 47.8f, 47.7f, 47.7f, 47.7f, 20.7f, 20.6f, 20.5f, 20.4f, 20.3f,20.2f, 14.4f, 14.4f, 65.3f, 27.7f, 27.7f, 67.6f, 67.6f, 67.6f, 34.8f,34.8f, 34.8f, 34.8f, 34.8f, 34.8f, 34.8f, 34.8f, 34.8f, 94.8f, 94.8f,94.8f, 67.0f, 66.9f, 66.8f, 66.7f, 66.6f, 66.5f, 66.4f, 66.3f, 9.8f,9.8f, 9.8f, 9.8f, 9.8f, 9.8f, 9.8f, 9.8f, 82.3f, 82.3f, 32.1f,32.1f, 23.0f, 22.9f, 22.8f, 88.4f, 88.3f, 88.2f, 88.1f, 88.0f, 87.9f,87.8f, 87.9f, 87.9f, 87.9f, 52.1f, 52.0f, 52.1f, 52.1f, 59.5f, 59.5f,75.0f, 75.0f, 75.0f, 82.4f, 82.5f, 82.6f, 82.7f, 82.8f, 82.9f, 83.0f,83.1f, 83.0f, 83.0f, 51.9f, 51.9f, 51.9f, 51.9f, 69.6f, 69.5f, 91.1f,91.0f, 90.9f, 90.8f, 90.7f, 90.6f, 90.5f, 59.2f, 59.1f, 59.0f, 58.9f,58.8f, 58.7f, 58.6f, 58.5f, 58.4f, 34.3f, 34.3f, 34.3f, 70.1f, 70.0f,69.9f, 69.8f, 69.7f, 69.6f, 69.5f, 69.4f, 88.3f, 88.4f, 88.5f, 88.6f,88.7f, 88.8f, 88.9f, 89.0f, 82.1f, 82.2f, 82.3f, 82.4f, 82.5f, 82.6f,82.7f, 82.8f, 82.9f, 14.1f, 14.1f, 14.1f, 2.6f, 2.7f, 2.8f, 2.9f,2.8f, 2.8f, 2.8f, 19.2f, 19.1f, 19.0f, 18.9f, 18.8f, 49.6f, 49.5f,49.4f, 49.3f, 61.8f, 61.9f, 62.0f, 62.1f, 56.6f, 18.1f, 18.0f, 17.9f,17.8f, 17.7f, 17.6f, 17.5f, 17.4f, 1.7f, 1.8f, 1.9f, 2.0f, 2.1f,2.2f, 2.3f, 2.4f, 46.8f, 46.7f, 46.6f, 46.5f, 46.4f, 46.3f, 46.2f,46.1f, 46.1f, 81.0f, 81.0f, 81.0f, 71.1f, 71.2f, 71.3f, 71.4f, 71.5f,71.6f, 71.7f, 71.8f, 71.9f, 74.0f, 13.0f, 13.1f, 69.3f, 69.3f, 40.9f,40.8f, 40.7f, 40.6f, 40.5f, 40.4f, 40.3f, 39.3f, 39.4f, 39.5f, 39.6f,39.7f, 39.8f, 39.9f, 40.0f, 40.1f, 59.3f, 59.2f, 59.1f, 59.0f, 58.9f,58.8f, 58.9f, 58.9f, 58.9f, 58.9f, 58.9f, 28.8f, 28.9f, 29.0f, 29.1f,29.2f, 29.3f, 29.4f, 29.5f, 29.6f, 78.4f, 78.3f, 78.2f, 78.1f, 78.0f,77.9f, 77.8f, 20.3f, 20.4f, 20.5f, 20.6f, 20.7f, 20.8f, 20.9f, 21.0f,21.1f, 21.0f, 38.3f, 38.2f, 38.1f, 38.0f, 37.9f, 37.8f, 37.7f, 37.6f,27.3f, 27.4f, 27.5f, 27.6f, 27.5f, 17.7f, 17.6f, 17.5f, 17.4f, 17.3f,17.2f, 17.3f, 17.3f, 53.1f, 53.0f, 52.9f, 52.8f, 52.7f, 71.5f, 71.6f,71.7f, 71.8f, 71.9f, 72.0f, 72.1f, 72.2f, 72.3f, 28.1f, 28.0f, 27.9f,27.8f, 68.1f, 68.1f, 68.1f, 68.1f, 68.1f, 68.1f, 1.4f, 68.1f, 72.0f,71.9f, 71.8f, 71.7f, 71.6f, 71.5f, 71.4f, 0.4f, 16.6f, 16.6f, 33.5f,33.5f, 33.5f, 12.3f, 12.3f, 12.3f, 12.4f, 12.4f, 12.4f, 10.2f, 10.3f,10.4f, 10.5f, 25.7f, 25.6f, 25.5f, 25.4f, 25.3f, 25.2f, 25.1f, 25.0f,42.1f, 42.0f, 41.9f, 41.8f, 92.5f, 92.4f, 92.3f, 92.2f, 92.1f, 92.0f,91.9f, 91.8f, 16.2f, 16.3f, 16.2f, 16.3f, 16.3f, 16.3f, 19.9f, 19.8f,19.7f, 19.6f, 19.7f, 19.7f, 19.7f, 19.7f, 91.8f, 91.8f, 12.0f, 11.9f,11.8f, 11.7f, 11.6f, 11.5f, 11.4f, 11.3f, 33.7f, 33.8f, 93.3f, 93.2f,93.1f, 93.0f, 92.9f, 92.8f, 92.7f, 15.6f, 15.6f, 15.6f, 22.9f, 23.0f,23.1f, 23.2f, 23.3f, 23.4f, 23.5f, 23.6f, 23.7f, 7.5f, 7.6f, 7.7f,7.8f, 7.9f, 8.0f, 8.1f, 31.0f, 66.2f, 66.3f, 66.4f, 66.5f, 53.8f,53.8f, 90.5f, 53.8f, 49.9f, 49.9f, 49.9f, 49.9f, 39.8f, 39.9f, 39.8f,39.9f, 39.9f, 39.9f, 39.9f, 39.9f, 39.9f, 44.5f, 44.6f, 44.5f, 44.5f,44.5f, 47.8f, 44.5f, 83.6f, 83.6f, 14.5f, 14.4f, 14.3f, 23.6f, 23.6f,23.6f, 23.6f, 23.6f, 23.4f, 23.3f, 23.2f, 23.1f, 23.0f, 22.9f, 22.8f,22.7f, 22.6f, 26.5f, 26.6f, 26.7f, 26.8f, 26.9f, 27.0f, 27.1f, 27.2f,27.3f, 32.0f, 32.1f, 32.2f, 32.3f, 32.4f, 32.5f, 32.6f, 31.0f, 31.1f,31.2f, 31.3f, 31.2f, 31.2f, 31.2f, 28.5f, 28.4f, 28.3f, 28.2f, 28.1f,28.0f, 27.9f, 27.8f, 86.1f, 86.1f, 86.1f, 13.0f, 12.9f, 12.8f, 12.7f,88.3f, 88.4f, 88.5f, 88.6f, 67.9f, 68.0f, 68.1f, 68.2f, 68.3f, 94.4f,92.9f, 73.1f, 73.0f, 72.9f, 72.8f, 72.7f, 72.6f, 72.5f, 60.9f, 43.6f,2.1f, 2.0f, 1.9f, 1.8f, 16.5f, 16.6f, 65.1f, 65.1f, 65.1f, 65.1f,65.1f, 23.6f, 23.7f, 23.8f, 23.9f, 24.0f, 24.1f, 24.2f, 63.4f, 63.3f,63.2f, 63.1f, 63.0f, 86.8f, 86.9f, 87.0f, 87.1f, 87.2f, 87.3f, 87.4f,87.5f, 87.5f, 87.5f, 26.1f, 26.1f, 26.1f, 26.1f, 0.1f, 0.1f, 13.3f,13.4f, 13.5f, 13.6f, 13.7f, 13.8f, 13.9f, 22.5f, 22.5f, 90.5f, 94.9f,86.0f, 86.0f, 86.0f, 86.0f, 86.0f, 86.0f, 37.7f, 37.6f, 37.5f, 37.4f,37.3f, 37.3f, 37.3f, 37.3f, 98.3f, 40.8f, 40.8f, 40.8f, 40.8f, 40.8f,40.8f, 40.8f, 47.6f, 47.5f, 47.4f, 47.3f, 47.2f, 47.1f, 47.0f, 46.9f
    
    
    //Re-running all edge cases on  05 January 2026
    
    //DA(*A*-D)  *
    //35.3f, 35.2f, 35.1f, 85.6f, 85.7f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f,19.8f
    //TICKER: D(3)A(2)A(5)-D(3)
    //[35.3->35.1, 85.6->85.7, 19.6->20.0, 20.0->19.8
    
    //SA(*A*-D)  *
    //35.1f,85.6f, 85.7f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: SA(2)A(5)-D(3)
    //[35.1, 85.6->85.7, 19.6->20.0, 20.0->19.8]
    
    //AA(*A*-D)  *
    //35.1f,35.2f, 85.6f, 85.7f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: A(2)A(2)A(5)-D(3)
    //[35.1->35.2, 85.6->85.7, 19.6->20.0, 20.0->19.8]
    
    //DD(*A*-D)  *
    //35.1f,35.0f,55.2f,55.1f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: D(2)D(2)A(5)-D(3)
    //[35.1->35.0, 55.2->55.1, 19.6->20.0, 20.0->19.8]
    
    //SS(*A*-D)  *
    //35.1f,55.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: SSA(5)-D(3)
    //[35.1, 55.2, 19.6->20.0, 20.0->19.8]

    //AS(*A*-D) *
    //35.1f,35.2f, 55.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: A(2)SA(5)-D(3)
    //[35.1->35.2, 55.2, 19.6->20.0, 20.0->19.8]
    
    //DS(*A*-D)  *
    //35.2f,35.1f, 55.2f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: D(2)SA(5)-D(3)
    //[35.2->35.1, 55.2, 19.6->20.0, 20.0->19.8]
    
    //SS(*A*-D)  *
    //35.2f,35.6f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: SSA(5)-D(3)
    //[35.2, 35.6, 19.6->20.0, 20.0->19.8]
    
    //AD(*A*-D)
    //35.1f,35.2f, 55.2f,55.1f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: A(2)D(2)A(5)-D(3)
    //[35.1->35.2, 55.2->55.1, 19.6->20.0, 20.0->19.8]
    
    //SD(*A*-D)
    //35.1f,55.2f,55.1f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: SD(2)A(5)-D(3)
    //[35.1, 55.2->55.1, 19.6->20.0, 20.0->19.8]
    
    //A-D(*A*-D)
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: A(5)-D(3)A(5)-D(3)
    //[19.6->20.0, 20.0->19.8, 19.6->20.0, 20.0->19.8]
    
    //D-A(*A*-D)
    //19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.3f, 19.4f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: D(5)-A(3)A(5)-D(3)
    //[19.6->19.2, 19.2->19.4, 19.6->20.0, 20.0->19.8]

    //A-D(*D*-A)
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 19.6f, 19.5f, 19.4f, 19.3f, 19.4f, 19.5f, 19.6f
    //TICKER: A(5)-D(3)D(4)-A(4)
    //[19.6->20.0, 20.0->19.8, 19.6->19.3, 19.3->19.6]
    
    //D-A(*D*-A)
    //19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.3f, 19.4f, 19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.3f, 19.4f
    //TICKER: D(5)-A(3)D(5)-A(3)
    //[19.6->19.2, 19.2->19.4, 19.6->19.2, 19.2->19.4]
    
    //(A-D)*A
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f,56.7f,56.8f,56.9f
    //TICKER: A(5)-D(3)A(3)
    //[19.6->20.0, 20.0->19.8, 56.7->56.9]
    
    //(A-D)*D
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f,56.7f,56.6f,56.5f
    //TICKER: A(5)-D(3)D(3)
    //[19.6->20.0, 20.0->19.8, 56.7->56.5]

    
    //***GENERATED BY CHATGPT************
    //35.1f, 85.6f, 85.7f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f 
    
    //35.1f, 35.2f, 85.6f, 85.7f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: A(2)A(2)A(5)-D(3)
    //[35.1->35.2, 85.6->85.7, 19.6->20.0, 20.0->19.8]
    
    //35.1f, 35.2f, 55.2f, 55.1f, 19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: A(2)D(2)A(5)-D(3)
    //[35.1->35.2, 55.2->55.1, 19.6->20.0, 20.0->19.8]
    
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f,
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: A(5)-D(3)A(5)-D(3)
    //[19.6->20.0, 20.0->19.8, 19.6->20.0, 20.0->19.8]
    
    //19.6f, 19.5f, 19.4f, 19.3f, 19.2f, 19.3f, 19.4f,
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //TICKER: D(5)-A(3)A(5)-D(3)
    //[19.6->19.2, 19.2->19.4, 19.6->20.0, 20.0->19.8]
    
    
    //***GENERATED BY CHATGPT************PLATEAU***********05 January 2026
    //19.3f, 19.3f, 19.3f
    
    //19.6f, 19.5f, 19.4f, 19.3f, 19.3f, 19.3f, 19.2f, 19.1f
    
    //1.0f, 1.1f, 1.2f, 1.3f, 1.3f, 1.3f, 1.4f, 1.5f
    
    //1.0f, 1.1f, 1.2f, 1.3f, 1.3f, 1.3f, 1.2f, 1.1f
    
    //5.0f, 4.9f, 4.8f, 4.7f, 4.7f, 4.7f, 4.8f, 4.9f
      
    //10.0f, 10.0f, 10.0f, 10.1f, 10.2f
    
    //2.0f, 1.9f, 1.8f, 1.8f, 1.8f 
        
    //7.0f, 7.0f, 7.1f, 7.2f, 7.2f, 7.2f
    
    
    //EXTRA CHATGPT SANITY TEST CASES BY CHATGPT (BASED ON LATEST PLATEAU CODE INTEGRATION)
    //06 January 2026
    //1.0f, 1.1f, 1.2f, 1.1f, 1.0f
    //5.0f, 4.9f, 4.8f, 4.9f, 5.0f
    //1.0f, 1.1f, 1.2f, 1.3f, 1.3f, 1.3f, 1.2f, 1.1f
    //10.0f, 10.0f, 10.0f, 10.1f, 10.2f
    //7.0f, 7.0f, 7.1f, 7.2f, 7.2f, 7.2f
    //7.0f, 7.0f, 7.1f, 7.2f, 7.2f, 7.2f
    
    //10.0f, 10.0f, 10.1f
    
    //FURTHER PLATEAU
    //7.0f, 7.0f
    //19.3f, 19.3f, 19.3f
    //10.0f, 10.0f, 10.0f, 10.1f, 10.2f
    //19.6f, 19.5f, 19.4f, 19.3f, 19.3f, 19.2f, 19.1f
    
    //Quick sanity checks you can do
    //These should behave like:

    //35.1, 55.2, 19.6, 19.7 -> SSA(2) (two standalones then ascending)

    //7.0, 7.0 -> P(2) (NOT SS)

    //10.0, 10.0, 10.1 -> P(2)A(2) (NOT SS...)
    
    
    
    
    /*
    //----------TEST CASE----------
    //THIS WAS WHEN CHATGPT HAD DIFFERENT epsilon set for AMIT and CHATGPT
    
    //requires these configured
    static final float epsilon = 0.000001f;
    static float difference=0.001f;

    final float STEP = 0.001f;
    final float EPS = 0.000001f;
    
    10.000f, 10.000f, 10.000f, 10.001f, 10.002f, 10.003f, 10.004f, 10.005f, 10.006f, 10.007f,
    10.008f, 10.009f, 10.010f, 10.011f, 10.012f, 10.013f, 10.014f, 10.015f, 10.016f, 10.017f,
    10.018f, 10.019f, 10.020f, 10.021f, 10.022f, 10.023f, 10.024f, 10.025f, 10.026f, 10.027f,
    10.028f, 10.029f, 10.030f, 10.031f, 10.032f, 10.033f, 10.034f, 10.035f, 10.036f, 10.037f,
    10.038f, 10.039f, 10.040f, 10.041f, 10.042f, 10.043f, 10.044f, 10.045f, 10.046f, 10.047f,
    10.048f, 10.049f, 10.050f, 10.051f, 10.052f, 10.053f, 10.054f, 10.055f, 10.056f, 10.057f,
    10.058f, 10.059f, 10.060f, 10.059f, 10.058f, 10.057f, 10.056f, 10.055f, 10.054f, 10.053f,
    10.052f, 10.051f, 10.050f, 10.049f, 10.048f, 10.047f, 10.046f, 10.045f, 10.044f, 10.043f,
    10.042f, 10.041f, 10.040f, 10.039f, 10.038f, 10.037f, 10.036f, 10.035f, 10.034f, 10.033f,
    10.032f, 10.031f, 10.030f, 10.030f, 10.030f, 10.030f, 10.030f, 10.029f, 10.028f, 10.027f,
    10.026f, 10.025f, 10.024f, 10.023f, 10.022f, 10.021f, 10.020f, 10.019f, 10.018f, 10.017f,
    10.016f, 10.015f, 10.014f, 10.013f, 10.012f, 10.011f, 10.010f, 10.009f, 10.008f, 10.007f,
    10.006f, 10.005f, 10.004f, 10.003f, 10.002f, 10.001f, 10.000f, 9.999f, 9.998f, 9.997f,
    9.996f, 9.995f, 9.994f, 9.993f, 9.992f, 9.991f, 9.990f, 25.50f, 25.501f, 25.502f,
    25.503f, 25.504f, 25.505f, 25.506f, 25.507f, 25.508f, 25.509f, 25.510f, 25.511f,
    25.512f, 25.513f, 25.514f, 25.515f, 25.516f, 25.517f, 25.518f, 25.519f, 25.520f,
    25.521f, 25.522f, 25.523f, 25.524f, 25.525f, 25.526f, 25.527f, 25.528f, 25.529f,
    25.530f, 25.531f, 25.532f, 25.533f, 25.534f, 25.535f, 25.536f, 25.537f, 25.538f,
    25.539f, 25.540f, 25.541f, 25.542f, 25.543f, 25.544f, 25.545f, 25.545f, 25.545f,
    25.544f, 25.543f, 25.542f, 25.541f, 25.540f, 25.539f, 25.538f, 25.537f, 25.536f,
    25.535f, 25.534f, 25.533f, 25.532f, 25.531f, 25.530f, 25.529f, 25.528f, 25.527f,
    25.526f, 25.525f, 5.25f, 5.251f, 5.252f, 5.253f, 5.254f, 5.255f, 5.256f, 5.257f,
    5.258f, 5.259f, 5.260f, 5.261f, 5.262f, 5.263f, 5.264f, 5.265f, 5.266f, 5.267f,
    5.268f, 5.269f, 5.270f, 5.271f, 5.272f, 5.273f, 5.274f, 5.275f, 5.276f, 5.277f,
    5.278f, 5.279f, 5.280f, 5.281f, 5.282f, 5.283f, 5.284f, 5.285f, 5.292f, 5.293f,
    5.294f, 5.295f, 5.296f, 5.297f, 5.298f, 5.299f, 5.300f, 5.301f, 5.302f, 5.303f,
    5.304f, 5.305f, 5.306f, 5.307f, 5.308f, 5.309f, 5.310f, 5.311f, 5.312f, 5.311f,
    5.310f, 5.309f, 5.308f, 5.309f, 5.310f, 5.311f, 5.312f, 5.313f, 5.312f, 5.311f,
    5.310f, 5.309f, 5.308f, 5.309f, 5.310f, 5.311f, 5.312f, 5.313f, 5.312f, 5.311f,
    5.310f, 5.309f, 5.308f, 5.309f, 5.310f, 5.311f, 5.312f, 5.313f, 5.314f, 5.313f,
    5.312f, 5.311f, 5.310f, 5.309f, 5.310f, 5.311f, 5.312f, 5.313f, 5.314f, 5.315f,
    5.314f, 5.313f, 5.312f, 5.311f, 5.310f, 5.311f, 5.312f, 5.313f, 5.314f, 5.315f,
    5.316f, 5.315f, 5.314f, 5.313f, 5.312f, 5.311f, 5.312f, 5.313f, 5.314f, 5.315f,
    5.316f, 5.317f, 5.316f, 5.315f, 5.314f, 5.313f, 5.312f, 5.313f, 5.314f, 5.315f,
    5.316f, 5.317f, 5.318f, 5.317f, 5.316f, 5.315f, 5.314f, 5.313f, 5.314f, 5.315f,
    5.316f, 5.317f, 5.318f, 5.319f, 5.318f, 5.317f, 5.316f, 5.315f, 5.314f, 5.315f,
    5.316f, 5.317f, 5.318f, 5.319f, 5.320f, 5.319f, 5.318f, 5.317f, 5.316f, 5.315f,
    5.316f, 5.317f, 5.318f, 5.319f, 5.320f, 5.321f, 5.320f, 5.319f, 5.318f, 5.317f,
    5.316f, 5.317f, 5.318f, 5.319f, 5.320f, 5.321f, 5.322f, 5.321f, 5.320f, 5.319f,
    5.318f, 5.317f, 5.318f, 5.319f, 5.320f, 5.321f, 5.322f, 5.323f, 5.322f, 5.321f,
    5.320f, 5.319f, 5.318f, 5.319f, 5.320f, 5.321f, 5.322f, 5.323f, 5.324f, 5.323f,
    5.322f, 5.321f, 5.320f, 5.319f, 5.320f, 5.321f, 5.322f, 5.323f, 5.324f, 5.325f,
    5.324f, 5.323f, 5.322f, 5.321f, 5.320f, 5.321f, 5.322f, 5.323f, 5.324f, 5.325f,
    5.326f, 5.325f, 5.324f, 5.323f, 5.322f, 5.321f, 5.322f, 5.323f, 5.324f, 5.325f,
    5.326f, 5.327f, 5.327f, 5.327f, 5.277f, 5.276f, 5.275f, 5.274f, 5.273f, 5.272f,
    5.271f, 5.270f, 5.269f, 5.268f, 5.267f, 5.266f, 5.265f, 5.264f, 5.263f, 5.262f,
    5.261f, 5.260f, 5.259f, 5.258f, 5.257f, 5.256f, 5.255f, 5.254f, 5.253f, 5.252f,
    5.251f, 5.250f, 5.249f, 5.248f, 5.247f, 5.246f, 5.245f, 5.244f, 5.243f, 5.242f,
    5.241f, 5.240f, 5.239f, 5.238f, 5.237f, 5.236f, 5.235f, 5.234f, 5.233f, 5.232f,
    5.231f, 5.230f, 5.229f, 5.228f, 5.227f, 5.226f, 5.225f, 5.224f, 5.223f, 5.222f,
    5.221f, 5.220f, 5.219f, 5.218f, 5.217f, 5.216f, 5.215f, 5.214f, 5.213f, 5.212f,
    5.211f, 5.210f, 5.209f, 5.208f, 5.207f, 5.206f, 5.205f, 5.204f, 5.203f, 5.202f,
    5.201f, 5.200f, 5.199f, 5.198f, 5.197f, 5.196f, 5.195f, 5.194f, 5.193f, 5.192f,
    5.191f, 5.190f, 5.189f, 5.188f, 5.187f, 5.186f, 5.185f, 5.184f, 5.183f, 5.182f,
    5.181f, 5.180f, 5.179f, 5.178f, 5.177f, 5.176f, 5.175f, 5.174f, 5.173f, 5.172f,
    5.171f, 5.170f, 5.169f, 5.168f, 5.167f, 5.166f, 5.165f, 5.164f, 5.163f, 5.162f,
    5.161f, 5.160f, 5.159f, 5.158f, 5.157f, 5.156f, 5.155f, 5.154f, 5.153f, 5.152f,
    5.151f, 5.150f, 5.149f, 5.148f, 5.147f, 5.146f, 5.145f, 5.144f, 5.143f, 5.142f,
    5.141f, 5.140f, 5.139f, 5.138f, 5.137f, 5.136f, 5.135f, 5.134f, 5.133f, 5.132f,
    5.131f, 5.130f, 5.129f, 5.128f, 5.127f, 5.126f, 5.125f, 5.124f, 5.123f, 5.122f,
    5.121f, 5.120f, 5.119f, 5.118f, 5.117f, 5.116f, 5.115f, 5.114f, 5.113f, 5.112f,
    5.111f, 5.110f, 5.109f, 5.108f, 5.107f, 5.106f, 5.105f, 5.104f, 5.103f, 5.102f,
    5.101f, 5.100f, 5.099f, 5.098f, 5.097f, 5.096f, 5.095f, 5.094f, 5.093f, 5.092f,
    5.091f, 5.090f, 5.089f, 5.088f, 5.087f, 5.086f, 5.085f, 5.084f, 5.083f, 5.082f,
    5.081f, 5.080f, 5.079f, 5.078f, 5.077f, 5.076f, 5.075f, 5.074f, 5.073f, 5.072f,
    5.071f, 5.070f, 5.069f, 5.068f, 5.067f, 5.066f, 5.065f, 5.064f, 5.063f, 5.062f,
    5.061f, 5.060f, 5.059f, 5.058f, 5.057f, 5.056f, 5.055f, 5.054f, 5.053f, 5.052f,
    5.051f, 5.050f, 5.049f, 5.048f, 5.047f, 5.046f, 5.045f, 5.044f, 5.043f, 5.042f,
    5.041f, 5.040f, 5.039f, 5.038f, 5.037f, 5.036f, 5.035f, 5.034f, 5.033f, 5.032f,
    5.031f, 5.030f, 5.029f, 5.028f, 5.027f, 5.026f, 5.025f, 5.024f, 5.023f, 5.022f,
    5.021f, 5.020f, 5.019f, 5.018f, 5.017f, 5.016f, 5.015f, 5.014f, 5.013f, 5.012f,
    5.011f, 5.010f, 5.009f, 5.008f, 5.007f, 5.006f, 5.005f, 5.004f, 5.003f, 5.002f,
    5.001f, 5.000f, 15.780f, 15.779f, 15.778f, 15.777f, 15.776f, 15.775f, 15.774f, 15.769f,
    50.73f, 50.731f
    */
    
    
    //***********************CHATGPT TEST CASES NOT ALWAYS GIVING THE REQUIREMENT DELTA SOUGHT*********************************************
    //UNDERSTANDABLE DUE TO EXTREME COMPUTE REQUIRED*********************************************

    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //This is intentionally "reset-heavy": a clean D run, then a boundary, then new movement. 
    //In your codebase this type of structure is where D-run undercounts can occur (D=+1).
    //If your run doesn't show a D mismatch here, don't worry - it just means your current reset rules are tighter on A than D (common).    
    //1) A-run magnitude mismatches
    //35.3f, 35.2f, 35.1f, 85.6f, 85.7f,
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f
    //Expected buckets hit:
    //A-run magnitude mismatches: 1 (A typically +1)

    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //2) D-run magnitude mismatches (this one really does it)
    //38.3f, 38.4f, 38.4f, 98.1f, 75.9f, 12.3f,
    //17.1f, 17.1f, 66.2f, 70.0f, 69.9f, 82.1f, 82.0f
    //Expected buckets hit:
    //D-run magnitude mismatches: 1
    //In my run it produced D(2) vs D(4) (so D = +2).

    
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //1) A-run magnitude mismatch (known reliable)
    //35.3f, 35.2f, 35.1f,
    //85.6f, 85.7f,
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f

    
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //This is your classic case that often yields A(4) vs A(5) (A=+1).
    //2) D-run magnitude mismatch (mirror-style)
    //55.1f,
    //71.7f, 71.6f, 71.5f, 71.4f, 71.3f,
    //19.6f, 19.7f,
    //85.2f, 85.3f, 85.4f, 85.5f, 85.6f

    
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //Test cases for the "other buckets"
    //Bucket: Segment-type mismatch + A/D vs S mismatch (Ascending)
    //Amit will treat these as valid +0.1 steps; ChatGPT will treat them as S because they're ~0.1003.
    //1.0000f, 1.1003f, 1.2006f, 1.3009f, 1.4012f, 1.5015f
    //Expected bucket hits:
    //Segment-type mismatches (A/D/S): > 0
    //A/D vs S mismatches: > 0

    
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //Bucket: Segment-type mismatch + A/D vs S mismatch (Descending)
    //Same idea but downward (~0.1003 each step).
    //2.0000f, 1.8997f, 1.7994f, 1.6991f, 1.5988f
    //Expected bucket hits:
    //Segment-type mismatches (A/D/S): > 0
    //A/D vs S mismatches: > 0

    
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    // = 3 test cases (equal eps = 0.0005f, step = 0.1f)
    //A key detail first: with shared epsilon, =3 is not guaranteed (your current observed behavior is usually =0-1). The best way to try to produce =3 without changing eps is to create multiple adjacent A segments (or D segments) where each segment is typically undercounted by ~1 in the reset-aware ticker; then the merged comparison totals can differ by 3.
    //These two datasets are designed for that.
    //A-run   3 candidate
    //(Three ascending ranges separated by large jumps, likely to appear as A()A()A() in the raw ticker and merge into one big A(total) in comparison.)
    //10.0f, 10.1f, 10.2f, 10.3f, 10.4f,
    // Big jump (boundary)
    //80.6f,
    // Range 2: up
    //20.0f, 20.1f, 20.2f, 20.3f, 20.4f,
    // Big jump (boundary)
    //90.5f,
    // Range 3: up
    //30.0f, 30.1f, 30.2f, 30.3f, 30.4f,
    // Finish with a down run so you get a clean transition too
    //30.3f, 30.2f, 30.1f
    //What to look for:
    //Raw tickers containing something like ... A(x)A(y)A(z) ...

    
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //In merged comparison: <<<A(total)>>> differs by about 3 if each phase is discounted by 1 in Amit.
    //D-run   3 candidate
    //(Three descending ranges separated by large jumps.)
    // Range 1: down
    //40.4f, 40.3f, 40.2f, 40.1f, 40.0f,
    // Big jump (boundary)
    //12.3f,
    // Range 2: down
    //30.4f, 30.3f, 30.2f, 30.1f, 30.0f,
    // Big jump (boundary)
    //99.0f,
    // Range 3: down
    //20.4f, 20.3f, 20.2f, 20.1f, 20.0f,
    // Finish with a small up run
    //20.1f, 20.2f
    //what to look for:
    //Raw tickers like ... D(x)D(y)D(z) ...
    //Merged comparison: <<<D(total)>>> differs by about 3 if each phase is discounted by 1.

//****************************************************************************************************
    //ONCE ******CHATGPT HAD BIT MORE UNDERSTANDING OF SAME EPSILON/EPS and understood my requirements, it provided the following
    //test cases.. The above attempts did not render the expectations...
    
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //SUCCESS
    //A-run: target A = 2 (two blocks)
    // Block 1 (your known A=+1 pattern)
    //35.3f, 35.2f, 35.1f, 85.6f, 85.7f,
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f,
    // Block 2 (same shape, shifted values)
    //55.3f, 55.2f, 55.1f, 105.6f, 105.7f,
    //39.6f, 39.7f, 39.8f, 39.9f, 40.0f, 39.9f, 39.8f

    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //A-run: target A = 3 (three blocks)
    // Block 1
    //35.3f, 35.2f, 35.1f, 85.6f, 85.7f,
    //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f,
    // Block 2
    //55.3f, 55.2f, 55.1f, 105.6f, 105.7f,
    //39.6f, 39.7f, 39.8f, 39.9f, 40.0f, 39.9f, 39.8f,
    // Block 3
    //75.3f, 75.2f, 75.1f, 125.6f, 125.7f,
    //59.6f, 59.7f, 59.8f, 59.9f, 60.0f, 59.9f, 59.8f

    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    //FAIL***** - chatGPT has found assymetry in my code in D direction, it will update documentation
    //It does not find a delta
    //D-run: target D = 2 / 3
    //This one depends on whether your legacy logic actually produces D undercounts in the same repeatable 
    //way (it often does, but not always as consistently as A). 
    //Here's the mirrored block that's most likely to do it:
    //D-run: target D = 2 (two blocks)
    // Block 1 (mirror-style)
    //35.1f, 35.2f, 35.3f, 85.7f, 85.6f,
    //20.0f, 19.9f, 19.8f, 19.7f, 19.6f, 19.7f, 19.8f,
    // Block 2
    //55.1f, 55.2f, 55.3f, 105.7f, 105.6f,
    //40.0f, 39.9f, 39.8f, 39.7f, 39.6f, 39.7f, 39.8f
    
    
    //STRESS TEST CASES  13 January 2026
    //chatGPT now understands my code the best
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
    
  // Block 1
  //35.3f,35.2f,35.1f,85.6f,85.7f,19.6f,19.7f,19.8f,19.9f,20.0f,19.9f,19.8f,19.8f,
  // Block 2 (+100)
  //135.3f,135.2f,135.1f,185.6f,185.7f,119.6f,119.7f,119.8f,119.9f,120.0f,119.9f,119.8f,119.8f,
  // Block 3 (+200)
  //235.3f,235.2f,235.1f,285.6f,285.7f,219.6f,219.7f,219.8f,219.9f,220.0f,219.9f,219.8f,219.8f,
  // Block 4 (+300)
  //335.3f,335.2f,335.1f,385.6f,385.7f,319.6f,319.7f,319.8f,319.9f,320.0f,319.9f,319.8f,319.8f,
  // Block 5 (+400)
  //435.3f,435.2f,435.1f,485.6f,485.7f,419.6f,419.7f,419.8f,419.9f,420.0f,419.9f,419.8f,419.8f,
  // Block 6 (+500)
  //535.3f,535.2f,535.1f,585.6f,585.7f,519.6f,519.7f,519.8f,519.9f,520.0f,519.9f,519.8f,519.8f,
  // Block 7 (+600)
  //635.3f,635.2f,635.1f,685.6f,685.7f,619.6f,619.7f,619.8f,619.9f,620.0f,619.9f,619.8f,619.8f,
  // Block 8 (+700)
  //735.3f,735.2f,735.1f,785.6f,785.7f,719.6f,719.7f,719.8f,719.9f,720.0f,719.9f,719.8f,719.8f,
  // Block 9 (+800)
  //835.3f,835.2f,835.1f,885.6f,885.7f,819.6f,819.7f,819.8f,819.9f,820.0f,819.9f,819.8f,819.8f,
  // Block 10 (+900)
  //935.3f,935.2f,935.1f,985.6f,985.7f,919.6f,919.7f,919.8f,919.9f,920.0f,919.9f,919.8f,919.8f
  //Why this is good for "full flow"
  //Each block includes:
  //a descending run at the start (35.3  35.1)
  //an ascending mini-run (85.6  85.7)
  //a longer ascending run (19.6  20.0)
  //a descending close (20.0  19.8)
  //a plateau (19.8, 19.8)
 //then a huge S-jump into the next block (standalone/S behavior + closures)
 //So an end user sees: D, A, A, D, plateau, S jump, repeated 10, and the A mismatch accumulates cleanly to +10.  
 
 
 
 
 
  //STRESS TEST CASES  13 January 2026
    //chatGPT now understands my code the best
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
 
 //Yep - here's a stress / edge-flow version that keeps the classic A(+1) block intact 
 //10 (so you should get A  10), but also forces a lot more junction activity via:
 //pre-block plateau
 //AD transition micro-swing
 //big S jump into the " block"
 //post-block micro-swing + S jump out
 //I've built it so each block is isolated by large S-jumps, so the internal " block" shouldn't get merged with neighbors.
 
 //Stress edge test case (10 blocks, lots of junctions, A expected  10)
 
 
  // ---------------- Block 1 (base 0) ----------------
  //900.0f, 900.0f, 900.1f, 900.2f, 900.1f,                  // plateau + A-D micro transition
  //35.3f, 35.2f, 35.1f, 85.6f, 85.7f,                        // classic A block begins
  //19.6f, 19.7f, 19.8f, 19.9f, 20.0f, 19.9f, 19.8f, 19.8f,  // includes plateau at end
  //910.0f, 910.1f, 910.0f,                                   // micro transition after block
  //999.0f,                                                   // S jump out

  // ---------------- Block 2 (base 1000) ----------------
  //1900.0f, 1900.0f, 1900.1f, 1900.2f, 1900.1f,
  //1035.3f, 1035.2f, 1035.1f, 1085.6f, 1085.7f,
  //1019.6f, 1019.7f, 1019.8f, 1019.9f, 1020.0f, 1019.9f, 1019.8f, 1019.8f,
  //1910.0f, 1910.1f, 1910.0f,
  //1999.0f,

  // ---------------- Block 3 (base 2000) ----------------
  //2900.0f, 2900.0f, 2900.1f, 2900.2f, 2900.1f,
  //2035.3f, 2035.2f, 2035.1f, 2085.6f, 2085.7f,
  //2019.6f, 2019.7f, 2019.8f, 2019.9f, 2020.0f, 2019.9f, 2019.8f, 2019.8f,
  //2910.0f, 2910.1f, 2910.0f,
  //2999.0f,

  // ---------------- Block 4 (base 3000) ----------------
  //3900.0f, 3900.0f, 3900.1f, 3900.2f, 3900.1f,
  //3035.3f, 3035.2f, 3035.1f, 3085.6f, 3085.7f,
  //3019.6f, 3019.7f, 3019.8f, 3019.9f, 3020.0f, 3019.9f, 3019.8f, 3019.8f,
  //3910.0f, 3910.1f, 3910.0f,
  //3999.0f,

  // ---------------- Block 5 (base 4000) ----------------
  //4900.0f, 4900.0f, 4900.1f, 4900.2f, 4900.1f,
  //4035.3f, 4035.2f, 4035.1f, 4085.6f, 4085.7f,
  //4019.6f, 4019.7f, 4019.8f, 4019.9f, 4020.0f, 4019.9f, 4019.8f, 4019.8f,
  //4910.0f, 4910.1f, 4910.0f,
  //4999.0f,

  // ---------------- Block 6 (base 5000) ----------------
  //5900.0f, 5900.0f, 5900.1f, 5900.2f, 5900.1f,
  //5035.3f, 5035.2f, 5035.1f, 5085.6f, 5085.7f,
  //5019.6f, 5019.7f, 5019.8f, 5019.9f, 5020.0f, 5019.9f, 5019.8f, 5019.8f,
  //5910.0f, 5910.1f, 5910.0f,
  //5999.0f,

  // ---------------- Block 7 (base 6000) ----------------
  //6900.0f, 6900.0f, 6900.1f, 6900.2f, 6900.1f,
  //6035.3f, 6035.2f, 6035.1f, 6085.6f, 6085.7f,
  //6019.6f, 6019.7f, 6019.8f, 6019.9f, 6020.0f, 6019.9f, 6019.8f, 6019.8f,
  //6910.0f, 6910.1f, 6910.0f,
  //6999.0f,

  // ---------------- Block 8 (base 7000) ----------------
  //7900.0f, 7900.0f, 7900.1f, 7900.2f, 7900.1f,
  //7035.3f, 7035.2f, 7035.1f, 7085.6f, 7085.7f,
  //7019.6f, 7019.7f, 7019.8f, 7019.9f, 7020.0f, 7019.9f, 7019.8f, 7019.8f,
  //7910.0f, 7910.1f, 7910.0f,
  //7999.0f,

  // ---------------- Block 9 (base 8000) ----------------
  //8900.0f, 8900.0f, 8900.1f, 8900.2f, 8900.1f,
  //8035.3f, 8035.2f, 8035.1f, 8085.6f, 8085.7f,
  //8019.6f, 8019.7f, 8019.8f, 8019.9f, 8020.0f, 8019.9f, 8019.8f, 8019.8f,
  //8910.0f, 8910.1f, 8910.0f,
  //8999.0f,

  // ---------------- Block 10 (base 9000) ----------------
  //9900.0f, 9900.0f, 9900.1f, 9900.2f, 9900.1f,
  //9035.3f, 9035.2f, 9035.1f, 9085.6f, 9085.7f,
  //9019.6f, 9019.7f, 9019.8f, 9019.9f, 9020.0f, 9019.9f, 9019.8f, 9019.8f,
  //9910.0f, 9910.1f, 9910.0f,
  //9999.0f
  
  
  //STRESS TEST CASES  13 January 2026
    //chatGPT now understands my code the best
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
     // Block 1 (base ~101)
    //Stress "trading floor feed" dataset (target A  +10) 
  101.30f, 101.20f, 101.10f,   101.60f, 101.70f,
  101.20f, 101.30f, 101.40f, 101.50f, 101.60f, 101.50f, 101.40f, 101.40f,
  102.45f, // "odd print"/gap (S)

  // Block 2 (base ~102.1)
  102.10f, 102.00f, 101.90f,   102.40f, 102.50f,
  102.00f, 102.10f, 102.20f, 102.30f, 102.40f, 102.30f, 102.20f, 102.20f,
  103.35f,

  // Block 3 (base ~102.9)
  102.90f, 102.80f, 102.70f,   103.20f, 103.30f,
  102.80f, 102.90f, 103.00f, 103.10f, 103.20f, 103.10f, 103.00f, 103.00f,
  104.15f,

  // Block 4 (base ~103.7)
  103.70f, 103.60f, 103.50f,   104.00f, 104.10f,
  103.60f, 103.70f, 103.80f, 103.90f, 104.00f, 103.90f, 103.80f, 103.80f,
  104.95f,

  // Block 5 (base ~104.5)
  104.50f, 104.40f, 104.30f,   104.80f, 104.90f,
  104.40f, 104.50f, 104.60f, 104.70f, 104.80f, 104.70f, 104.60f, 104.60f,
  105.75f,

  // Block 6 (base ~105.3)
  105.30f, 105.20f, 105.10f,   105.60f, 105.70f,
  105.20f, 105.30f, 105.40f, 105.50f, 105.60f, 105.50f, 105.40f, 105.40f,
  106.55f,

  // Block 7 (base ~106.1)
  106.10f, 106.00f, 105.90f,   106.40f, 106.50f,
  106.00f, 106.10f, 106.20f, 106.30f, 106.40f, 106.30f, 106.20f, 106.20f,
  107.35f,

  // Block 8 (base ~106.9)
  106.90f, 106.80f, 106.70f,   107.20f, 107.30f,
  106.80f, 106.90f, 107.00f, 107.10f, 107.20f, 107.10f, 107.00f, 107.00f,
  108.15f,

  // Block 9 (base ~107.7)
  107.70f, 107.60f, 107.50f,   108.00f, 108.10f,
  107.60f, 107.70f, 107.80f, 107.90f, 108.00f, 107.90f, 107.80f, 107.80f,
  108.95f,

  // Block 10 (base ~108.5)
  108.50f, 108.40f, 108.30f,   108.80f, 108.90f,
  108.40f, 108.50f, 108.60f, 108.70f, 108.80f, 108.70f, 108.60f, 108.60f,
  109.75f
  
  
  
   //STRESS TEST CASES  13 January 2026
    //chatGPT now understands my code the best
    //----------TEST CASE----------UNCOMMENT ALL //FOR THE DATA
   //Got it. Here's a "market feed / tape" stress case that keeps your A stacking mechanism 
  //(so A should be  10), but also deliberately runs through more junction types per block:
  //pre-plateau
  //micro whipsaw (A-D-A / D-A-D style around the same level)
  //big S gap
  //classic A(+1) block
  //post-block whipsaw
  //double plateau
  //another S gap
  //Market-feed stress dataset (junction-rich, A expected  10)
  
  /*
  // ========= Block 1 =========
  100.00f, 100.004f, 100.1021f, 100.0f, 100.10f,      // plateau + whipsaw A-D-A
  101.9f,                                           // gap print (S)
  101.30f, 101.20f, 101.10f, 101.60f, 101.70f,       // classic A block start
  101.20f, 101.30f, 101.40f, 101.50f, 101.60f, 101.50f, 101.40f, 101.40f,
  101.55f, 101.45f, 101.55f,                         // post whipsaw D-A
  101.55f, 101.55f,                                  // extra plateau
  102.80f,                                           // S gap out

  // ========= Block 2 =========
  101.20f, 101.20f, 101.30f, 101.20f, 101.30f,
  102.10f,
  102.10f, 102.00f, 101.90f, 102.40f, 102.50f,
  102.00f, 102.10f, 102.20f, 102.30f, 102.40f, 102.30f, 102.20f, 102.20f,
  102.35f, 102.25f, 102.35f,
  102.35f, 102.35f,
  103.60f,

  // ========= Block 3 =========
  102.40f, 102.40f, 102.50f, 102.40f, 102.50f,
  103.00f,
  102.90f, 102.80f, 102.70f, 103.20f, 103.30f,
  102.80f, 102.90f, 103.00f, 103.10f, 103.20f, 103.10f, 103.00f, 103.00f,
  103.15f, 103.05f, 103.15f,
  103.15f, 103.15f,
  104.40f,

  // ========= Block 4 =========
  103.60f, 103.60f, 103.70f, 103.60f, 103.70f,
  104.05f,
  103.70f, 103.60f, 103.50f, 104.00f, 104.10f,
  103.60f, 103.70f, 103.80f, 103.90f, 104.00f, 103.90f, 103.80f, 103.80f,
  103.95f, 103.85f, 103.95f,
  103.95f, 103.95f,
  105.20f,

  // ========= Block 5 =========
  104.80f, 104.80f, 104.90f, 104.80f, 104.90f,
  105.15f,
  104.50f, 104.40f, 104.30f, 104.80f, 104.90f,
  104.40f, 104.50f, 104.60f, 104.70f, 104.80f, 104.70f, 104.60f, 104.60f,
  104.75f, 104.65f, 104.75f,
  104.75f, 104.75f,
  106.00f,

  // ========= Block 6 =========
  106.00f, 106.00f, 106.10f, 106.00f, 106.10f,
  106.25f,
  105.30f, 105.20f, 105.10f, 105.60f, 105.70f,
  105.20f, 105.30f, 105.40f, 105.50f, 105.60f, 105.50f, 105.40f, 105.40f,
  105.55f, 105.45f, 105.55f,
  105.55f, 105.55f,
  106.80f,

  // ========= Block 7 =========
  106.90f, 106.90f, 107.00f, 106.90f, 107.00f,
  107.35f,
  106.10f, 106.00f, 105.90f, 106.40f, 106.50f,
  106.00f, 106.10f, 106.20f, 106.30f, 106.40f, 106.30f, 106.20f, 106.20f,
  106.35f, 106.25f, 106.35f,
  106.35f, 106.35f,
  108.10f,

  // ========= Block 8 =========
  107.70f, 107.70f, 107.80f, 107.70f, 107.80f,
  108.05f,
  106.90f, 106.80f, 106.70f, 107.20f, 107.30f,
  106.80f, 106.90f, 107.00f, 107.10f, 107.20f, 107.10f, 107.00f, 107.00f,
  107.15f, 107.05f, 107.15f,
  107.15f, 107.15f,
  108.90f,

  // ========= Block 9 =========
  108.40f, 108.40f, 108.50f, 108.40f, 108.50f,
  108.65f,
  107.70f, 107.60f, 107.50f, 108.00f, 108.10f,
  107.60f, 107.70f, 107.80f, 107.90f, 108.00f, 107.90f, 107.80f, 107.80f,
  107.95f, 107.85f, 107.95f,
  107.95f, 107.95f,
  109.70f,

  // ========= Block 10 =========
  109.10f, 109.10f, 109.20f, 109.10f, 109.20f,
  109.35f,
  108.50f, 108.40f, 108.30f, 108.80f, 108.90f,
  108.40f, 108.50f, 108.60f, 108.70f, 108.80f, 108.70f, 108.60f, 108.60f,
  108.75f, 108.65f, 108.75f,
  108.75f, 108.75f,
  110.50f
  
  //Plateau start (100.00, 100.00)
  //Micro whipsaw transitions (A-D-A around 100.xx)
  //S-jump (gap print)
  //Classic A block (your proven mismatch contributor)
  //D-A whipsaw after the block
  //Double plateau (x, x)
  //Another S-jump (gap out to next block)
  //So it lights up:
  //transitionEvents
  //plateau breakdown categories (between S/S, plateau end handling)
  //A/D run segmentation
  //"true behavioral differences" stacking
  */
};

    
    
    // --------------------CHATGPT---------------------
    // Precision / STEP detector (optional diagnostic)
    // Purpose: detect if the feed appears to be moving in a different STEP (e.g., 0.01 vs 0.1) and
    // estimate how much EPS would be needed to avoid missing near-step moves.
    static boolean SHOW_PRECISION_DETECTOR = true;
    static int PRECISION_WINDOW = 50; // rolling window size over deltas (nums[i+1]-nums[i])

    static class DeltaBucket {
        double value;      // bucketed delta (signed or abs)
        int count;
        double maxDeviation; // max |actual - bucket|
        DeltaBucket(double v) { value = v; }
    }

    static double roundTo(double v, int dp) {
        double p = Math.pow(10.0, dp);
        return Math.round(v * p) / p;
    }

    static void analyzePrecisionAndStep(float[] nums, float step, float eps) {
        if (!SHOW_PRECISION_DETECTOR || nums == null || nums.length < 2) return;

        // Collect deltas
        int nD = nums.length - 1;
        double[] deltas = new double[nD];
        for (int i = 0; i < nD; i++) {
            deltas[i] = (double)nums[i+1] - (double)nums[i];
        }

        // Buckets for ABS(|d|) and SIGNED(d) at 3dp (supports 0.001 / 0.01 / 0.1 feeds)
        java.util.Map<Double, DeltaBucket> absMap = new java.util.HashMap<>();
        java.util.Map<Double, DeltaBucket> signedMap = new java.util.HashMap<>();

        for (int i = 0; i < nD; i++) {
            double d = deltas[i];
            double abs = Math.abs(d);

            double absKey = roundTo(abs, 3);
            DeltaBucket ab = absMap.get(absKey);
            if (ab == null) { ab = new DeltaBucket(absKey); absMap.put(absKey, ab); }
            ab.count++;
            ab.maxDeviation = Math.max(ab.maxDeviation, Math.abs(abs - absKey));

            double sKey = roundTo(d, 3);
            DeltaBucket sb = signedMap.get(sKey);
            if (sb == null) { sb = new DeltaBucket(sKey); signedMap.put(sKey, sb); }
            sb.count++;
            sb.maxDeviation = Math.max(sb.maxDeviation, Math.abs(d - sKey));
        }

        // Rolling window: most common |d| in the LAST window
        int w = Math.min(PRECISION_WINDOW, nD);
        java.util.Map<Double, Integer> winCounts = new java.util.HashMap<>();
        for (int i = nD - w; i < nD; i++) {
            double k = roundTo(Math.abs(deltas[i]), 3);
            winCounts.put(k, winCounts.getOrDefault(k, 0) + 1);
        }
        double winMode = 0.0;
        int winModeCount = 0;
        for (java.util.Map.Entry<Double, Integer> e : winCounts.entrySet()) {
            int c = e.getValue();
            if (c > winModeCount) { winModeCount = c; winMode = e.getKey(); }
        }

        // Top K helpers
        java.util.List<DeltaBucket> topAbs = new java.util.ArrayList<>(absMap.values());
        java.util.List<DeltaBucket> topSigned = new java.util.ArrayList<>(signedMap.values());
        topAbs.sort((a,b) -> Integer.compare(b.count, a.count));
        topSigned.sort((a,b) -> Integer.compare(b.count, a.count));

        int total = nD;

        System.out.println("\n--- Precision / STEP detector ---");
        System.out.println("Configured STEP=" + step + "  EPS=" + eps + "  window=" + w + " deltas");
        System.out.println("Last-window most common |d| ~ " + winMode + "  (" + winModeCount + "/" + w + " = " + String.format(java.util.Locale.US, "%.1f", (100.0*winModeCount)/w) + "%)");

        // Global distribution of |d|
        System.out.println("Top |d| buckets (abs, 3dp):");
        int K = Math.min(10, topAbs.size());
        for (int i = 0; i < K; i++) {
            DeltaBucket b = topAbs.get(i);
            double pct = (100.0 * b.count) / total;
            // show 0.010 and -0.010 separately elsewhere; abs bucket is magnitude only
            System.out.println("  |d|=" + String.format(java.util.Locale.US, "%.3f", b.value) + "  count=" + b.count + "  (" + String.format(java.util.Locale.US, "%.1f", pct) + "%)  maxDev~" + String.format(java.util.Locale.US, "%.6f", b.maxDeviation));
        }

        // Signed distribution (keeps +0.010 and -0.010 separate)
        System.out.println("Top signed d buckets (3dp):");
        int Ks = Math.min(10, topSigned.size());
        for (int i = 0; i < Ks; i++) {
            DeltaBucket b = topSigned.get(i);
            double pct = (100.0 * b.count) / total;
            System.out.println("  d=" + String.format(java.util.Locale.US, "%+.3f", b.value) + "  count=" + b.count + "  (" + String.format(java.util.Locale.US, "%.1f", pct) + "%)  maxDev~" + String.format(java.util.Locale.US, "%.6f", b.maxDeviation));
        }

  
        // STEP candidate evaluation (diagnostic): try top observed |d| modes as candidate STEP values.
        System.out.println("STEP candidate evaluation (from top |d| modes):");
        java.util.LinkedHashSet<Double> candidates = new java.util.LinkedHashSet<>();
        for (int i = 0; i < topAbs.size() && candidates.size() < 6; i++) {
            double v = topAbs.get(i).value;
            if (v > 0.0000005) candidates.add(v); // ignore 0.000
        }
        // Always include the configured STEP for comparison (first).
        java.util.ArrayList<Double> candList = new java.util.ArrayList<>();
        candList.add((double)step);
        for (Double v : candidates) {
            if (Math.abs(v - step) > 1e-9) candList.add(v);
        }

        for (double candStep : candList) {
            int candStepLike = 0;
            double candMaxResid = 0.0;
            for (int i = 0; i < nD; i++) {
                double abs = Math.abs(deltas[i]);
                if (abs < 1e-12) continue; // plateau
                double kMul = Math.rint(abs / candStep);
                if (kMul < 1.0) continue;
                double target = kMul * candStep;
                double resid = Math.abs(abs - target);
                // Loose tolerance band for reporting (diagnostic only)
                if (resid <= (double)eps * 5.0) {
                    candStepLike++;
                    if (resid > candMaxResid) candMaxResid = resid;
                }
            }
            double pct = (100.0 * candStepLike) / total;
            System.out.println("  STEP=" + String.format(java.util.Locale.US, "%.3f", candStep)
                    + "  step-like=" + candStepLike + "/" + total
                    + " (" + String.format(java.util.Locale.US, "%.1f", pct) + "%)"
                    + "  maxResid~" + String.format(java.util.Locale.US, "%.6f", candMaxResid)
                    + "  epsNeeded>=" + String.format(java.util.Locale.US, "%.6f", (candMaxResid + 0.000001)));
        }
      // What EPS would be needed to classify moves as STEP or STEP-multiples without missing any near-step move?
        double maxResid = 0.0;
        int stepLike = 0;
        for (int i = 0; i < nD; i++) {
            double abs = Math.abs(deltas[i]);
            if (abs < 1e-12) continue; // plateau
            double kMul = Math.rint(abs / step); // nearest integer multiple
            if (kMul < 1.0) continue;
            double target = kMul * step;
            double resid = Math.abs(abs - target);
            // count as step-like if close-ish to some multiple
            if (resid <= (double)eps * 5.0) { // loose band for reporting
                stepLike++;
                if (resid > maxResid) maxResid = resid;
            }
        }
        System.out.println("STEP-fit check (to multiples of STEP): step-like moves=" + stepLike + "/" + total +
                " (" + String.format(java.util.Locale.US, "%.1f", (100.0*stepLike)/total) + "%)" +
                "  maxResid~" + String.format(java.util.Locale.US, "%.6f", maxResid));
        System.out.println("Suggested EPS to avoid losing any STEP-multiple move (heuristic): EPS >= " +
                String.format(java.util.Locale.US, "%.6f", (maxResid + 0.000001)));

        System.out.println("--- End Precision / STEP detector ---\n");
    }
    // --------------------END CHATGPT-------------------

public static void main (String[] args)
    {
        int lengthNums = nums.length;
    
        List<String> amitSummary = summaryRanges(nums,lengthNums);
System.out.println("Amit Amlani Tested Summary Range =>: " + amitSummary);
String amitTicker = completeTicker("END","END",0,lengthNums);
System.out.println("Amit Amlani Tested TICKER (magnitude/reset): 	" + amitTicker);

// --------------------CHATGPT---------------------
// Compare your ticker (magnitude/reset) to the ChatGPT ticker (shape-only)
if (lastChatgptTickerV2 != null)
{
    printTickerConsistency(amitTicker, lastChatgptTickerV2, lengthNums);
}
// -----------------------END CHATGPT-------------------
System.out.println(Arrays.toString(nums));
        // --------------------CHATGPT---------------------
// BUGFIX: Replaced legacy summary counts print; counts now derived from buildTickerV2.
// System.out.println("Standalone numbers: " + standaloneCount + "   Ascending chains: " + ascendingChainsComplete + "   Descending chains: " + descendingChainsComplete + "      TOTAL: " + tickerCounter);
// -----------------------END CHATGPT-------------------
        // --------------------CHATGPT---------------------
// BUGFIX: Replaced legacy transition count print; counts now derived from buildTickerV2.
// System.out.println("Transition events: " + transitionEvents);
// -----------------------END CHATGPT-------------------
        System.out.println("\n***NOTE: ChatGPT Ticker will NOW PASS under following constraints due to TickerResult (chatGPT generated");

	    System.out.println("DA (*A*-D)");
	    System.out.println("SA(*A*-D)");
	    System.out.println("AA(*A*-D)");
	    System.out.println("DD(*A*-D)");
	    System.out.println("D-A(*D*-A)");

	    System.out.println("See documentTransition events:ation for rationale");
	    System.out.println("https://www.amitamlani.com/30032025/SummaryRange/11/EXAMINING%20FUTURE%20WORK%20TO%20REMEDIATE%20THE%20TICKER.pdf");
        System.out.println("https://www.amitamlani.com/30032025/SummaryRange/11/Repository");

    
        // --------------------CHATGPT---------------------
        // Precision/STEP detector summary (prints at the very end to avoid cluttering the main ticker output)
        analyzePrecisionAndStep(nums, difference, epsilon);
        // --------------------END CHATGPT-------------------
}
    
    
    // --------------------CHATGPT---------------------
    // OFFICIAL CHANGE TO AMIT LEGACY TICKER:
    // Compress consecutive standalones: "SSS" -> "S(3)" (but keep single standalone as "S")
    private static String appendSCompressed(String currentTicker) {
        if (currentTicker == null) currentTicker = "";
        int n = currentTicker.length();
        if (n == 0) return "S";

        // If the ticker currently ends with "S", convert it to "S(2)"
        if (currentTicker.endsWith("S")) {
            return currentTicker.substring(0, n - 1) + "S(2)";
        }

        // If the ticker ends with "S(<digits>)", increment the number
        // (Only when it's truly the end; if something else follows, it won't match.)
        int close = currentTicker.lastIndexOf(')');
        if (close == n - 1) {
            int open = currentTicker.lastIndexOf('(', close);
            if (open > 0 && currentTicker.charAt(open - 1) == 'S') {
                String numStr = currentTicker.substring(open + 1, close);
                if (numStr.matches("\\d+")) {
                    int val = Integer.parseInt(numStr);
                    return currentTicker.substring(0, open + 1) + (val + 1) + ")";
                }
            }
        }

        // Otherwise start a new standalone run
        return currentTicker + "S";
    }
    // --------------------END CHATGPT-------------------

public static String completeTicker(String start, String end, int k, int lengthNums)
    {
        if (!start.equals("END") && !end.equals("END"))
        {
            tickerCounter++;
            
            if (start.equals(end))
            {
                // --------------------CHATGPT---------------------
                ticker = appendSCompressed(ticker);
                // --------------------END CHATGPT-------------------
                standaloneCount++;
                isStandalone=true;
                previousOutcome="standalone";
            }
            
            if(!isStandalone)
            {   
                if (Float.valueOf(end)>Float.valueOf(start))
                {
                    if (ascendingCounter==0 || ascendingCounter==1)
                    {
                        ascendingCounter=2;
                        hasAdjust=true;
                    }   
                    
                    if ((tickerCounter==1 || tickerCounter==2)
                    && (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon) 
                    && (!hasAdjust))
                    {
                           ascendingCounter=ascendingCounter+1;
                           hasAdjust=true;
                    }
                    
                    if ((previousOutcome=="standalone")
                    && (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon) 
                    && (!hasAdjust))
                    {
                        ascendingCounter=ascendingCounter+1;
                        hasAdjust=true;
                    }
                    
                    if ((k==lengthNums-2) && !hasAdjust)
                    {
                        ascendingCounter=ascendingCounter+1;
                    }
                    
                    if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                    {
                        ticker=ticker+"A"+"("+(ascendingCounter)+")-";
                        transitionEvents++;
                    }
                    else
                    {
                        ticker=ticker+"A"+"("+(ascendingCounter)+")";
                    }
                    
                    ascendingChainsComplete++;
                    ascendingCounter=0;
                    previousOutcome="";
                }
                else
                {
                    if (descendingCounter==0 || descendingCounter==1)
                    {
                        hasAdjust=true;
                        descendingCounter=2;
                    }
                    
                    if ((k==lengthNums-2) 
                    && (!hasAdjust)  
                    && (Math.abs(nums[k] - (nums[k+1] - difference)) >epsilon) 
                    && !(Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
                    {
                        descendingCounter=descendingCounter+1;
                        hasAdjust=true;
                    }
                    
                    if (!(Math.abs(Float.valueOf(start) - (Float.valueOf(end) + difference)) <epsilon)
                    && !(Math.abs(Float.valueOf(end) - (Float.valueOf(start) + difference)) <epsilon))
                    {
                        if (!(k==lengthNums-2) && descendingCounter>=2 && !hasAdjust)
                        {
                            descendingCounter=descendingCounter+1;
                            hasAdjust=true;
                        }
                        
                        if ((k==lengthNums-2) && descendingCounter>=2 && !hasAdjust)
                        {
                            if (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                            {
                                descendingCounter=descendingCounter+1;
                                hasAdjust=true;
                            }
                        }
                    }
                    
                    if (tickerCounter==1 && !hasAdjust  && !(k==lengthNums-2))
                    {   
                        descendingCounter=descendingCounter+1;
                    }
                    
                    if (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                    {
                        ticker=ticker+"D"+"("+(descendingCounter)+")-";
                        transitionEvents++;
                    }
                    else
                    {
                        ticker=ticker+"D"+"("+(descendingCounter)+")";
                    }
                    
                    descendingChainsComplete++;
                    descendingCounter=0;
                }
            }
        }
        
        hasStandaloneAfter=true;
        isStandalone=false;
        hasAdjust=false;
        
        if (!standaloneTemp.equals(""))
        {
            sm.add(standaloneTemp);
            ticker = appendSCompressed(ticker);
            standaloneCount++;
            standaloneTemp="";
        }
        
        //System.out.println("***********TICKER*********: " + ticker);
        
        return ticker;
    }
    
    public static List<String> summaryRanges(float[] nums, int lengthNums) 
    {
        boolean hasWrittenRepeatNumber=false;
        boolean isPrevNumAscending=false;
        boolean writtenPrevious=false;   
        boolean combineMerge=false;
        boolean hasNotWrittenLastNumber=true;
        boolean isFirstOccurenceAscendingChain=false;
        boolean isFirstOccurenceAscendingChainNoTransition =false;
        boolean hasWrittenStoreDueTransition = false;
        
        int counter = 0;
        String start="";
        String end="";
        String temp="";
        String backupStart="";
        
        String transitionNumber="";

        // --------------------CHATGPT  ΔD---------------------
        // State for optional descending confirmation-skip (persists across k iterations).
        boolean ddConfirmPrimed = false;
        String ddConfirmStart = "";
        // --------------------END CHATGPT  ΔD---------------------

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

            // --------------------CHATGPT---------------------
            // Ensure singleton arrays still produce the ChatGPT shape-only ticker + breakdown
            TickerResult tickerV2_single = buildTickerV2(nums, lengthNums);
            printChatgptBreakdown(tickerV2_single);
            lastChatgptTickerV2 = tickerV2_single;
            // --------------------END CHATGPT-----------------

            return sm;
        }

        for (int k=0; k<nums.length-1;k++)
        {
            // --------------------CHATGPT  ΔD---------------------
            // Drop a primed D-confirmation if the next step is not descending (prevents leaking across segments).
            if (ddConfirmPrimed && !(Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
            {
                ddConfirmPrimed = false;
                ddConfirmStart = "";
            }
            // --------------------END CHATGPT  ΔD---------------------

            if (k==0)
            {
                start=String.valueOf(nums[k]);
            }
            
            if (nums[k]!=nums[k+1])
            {
                System.out.println("\nCHECKING: " + nums[k] + " with " + nums[k+1]);
                //System.out.println("---------------------------VALS d: " + descendingCounter);
                //System.out.println("---------------------------VALS a: " + ascendingCounter);
                //System.out.println("---------------------------IN TICKER: " + ticker);
                //System.out.println(tickerCounter);
                //System.out.println(tickerCounterOnPreviousRange);
                //System.out.println("currently in list: " + sm);
                
                 if (!potentialfurtherAscendingBeyondThisStart.equals("") 
                 && !(potentialfurtherAscendingBeyondThisEnd.equals("")) 
                 && (nums[k+1]<=Float.valueOf(potentialfurtherAscendingBeyondThisStart)))
                 {
                     if (potentialfurtherAscendingBeyondThisStart.equals(nums[k]))
                     {
                         System.out.println("Stored value also ascending and overlap, not storing");
                         System.out.println("NO storage required");
                         potentialfurtherAscendingBeyondThisStart="";
                         potentialfurtherAscendingBeyondThisEnd="";
                    }
                }
                    
                if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                {
                    System.out.println("Descending sequence (difference)");

                    // --------------------CHATGPT  ΔD---------------------
                    // Optional: skip counting the FIRST descending step after a boundary if a second D-step follows.
                    boolean ddStartEmpty = (potentialfurtherAscendingBeyondThisStart=="") && (potentialfurtherAscendingBeyondThisEnd=="");
                    boolean ddLookahead = (k+2 < lengthNums) && (Math.abs(nums[k+1] - (nums[k+2] + difference)) <epsilon);
                    boolean ddBoundaryContext =
                            hasTransition
                            || (previousOutcome=="standalone")
                            || (k>0 && Math.abs(nums[k] - nums[k-1]) > (difference*2.0f));

                    if (ENABLE_DESCENDING_CONFIRMATION_SKIP && ddStartEmpty && ddBoundaryContext && ddLookahead && !ddConfirmPrimed)
                    {
                        // Prime: treat first D step as confirmation; start the run from nums[k+1] on next iteration.
                        ddConfirmPrimed = true;
                        ddConfirmStart = String.valueOf(nums[k+1]);
                        // Intentionally do NOT increment descendingCounter here.
                    }
                    else
                    {
                        descendingCounter++;

                        // If primed on previous k, start the stored range from the confirmed start.
                        if (ddStartEmpty && ddConfirmPrimed && ddConfirmStart.equals(String.valueOf(nums[k])))
                        {
                            start=ddConfirmStart;
                            end=String.valueOf(nums[k+1]);
                            potentialfurtherAscendingBeyondThisStart = start;
                            potentialfurtherAscendingBeyondThisEnd = end;
                            ddConfirmPrimed = false;
                            ddConfirmStart = "";
                        }
                    }
                    // --------------------END CHATGPT  ΔD---------------------
                    
                    System.out.println(potentialfurtherAscendingBeyondThisStart);
                    System.out.println(potentialfurtherAscendingBeyondThisEnd);
                    System.out.println(nums.length-2);
                    System.out.println(k);
                    
                    if ((potentialfurtherAscendingBeyondThisStart=="")
                    && (potentialfurtherAscendingBeyondThisEnd=="") 
                    && (k!=nums.length-2))
                    {
                        start=String.valueOf(nums[k]);
                        end=String.valueOf(nums[k+1]);
                        potentialfurtherAscendingBeyondThisStart = start; 
                        potentialfurtherAscendingBeyondThisEnd = end;
                        System.out.println("--------------------------------------12Stored start -> end: " 
                        + potentialfurtherAscendingBeyondThisStart + "->" + potentialfurtherAscendingBeyondThisEnd);
                    }
                    
                    //I identified my first instance of a failed summary range upon performing a chatGPT
                    //generated test case
                    //it skipped last two descending since k==nums.length-2
                    //38.3f, 38.4f, 38.4f, 98.1f, 75.9f, 12.3f,
                    //17.1f, 17.1f, 66.2f, 70.0f, 69.9f, 82.1f, 82.0f
                    
                    if ((potentialfurtherAscendingBeyondThisStart=="")
                    && (potentialfurtherAscendingBeyondThisEnd=="") 
                    && (k==nums.length-2))
                    {
                        System.out.println("curent start: " + k);
                        start=String.valueOf(nums[k]);
                        end=String.valueOf(nums[k+1]);
                        potentialfurtherAscendingBeyondThisStart = start; 
                        potentialfurtherAscendingBeyondThisEnd = end;
                        sm.add(potentialfurtherAscendingBeyondThisStart+"->"+end);
                        System.out.println("--------------------------------------129Stored start -> end: " 
                        + potentialfurtherAscendingBeyondThisStart + "->" + potentialfurtherAscendingBeyondThisEnd);
                        completeTicker(potentialfurtherAscendingBeyondThisStart,potentialfurtherAscendingBeyondThisEnd,k,lengthNums);
                        
                        potentialfurtherAscendingBeyondThisEnd="";
                        potentialfurtherAscendingBeyondThisStart="";
                        
                    }
                    
                    
                    
                    if (k!=0)
                    {
                        if ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon))
                        {
                            transitionNumber=String.valueOf(nums[k]);
                            System.out.println("2Transition number: " + transitionNumber + " descending(difference) on either side");
                            
                             if ((potentialfurtherAscendingBeyondThisEnd!="")
                             && (potentialfurtherAscendingBeyondThisEnd!=""))
                             {
                                 System.out.println("19821982using stored start");
                                 end=String.valueOf(nums[k]);
                                 sm.add(potentialfurtherAscendingBeyondThisStart+"->"+end);
                                 System.out.println("197618cWriting range: " + potentialfurtherAscendingBeyondThisStart+"->"+end);
                                 completeTicker(potentialfurtherAscendingBeyondThisStart,end,k,lengthNums);
                                 
                                 potentialfurtherAscendingBeyondThisEnd="";
                                 potentialfurtherAscendingBeyondThisStart="";
                                 
                                 start=String.valueOf(nums[k]);
                                 end=String.valueOf(nums[k+1]);
                                 
                                 potentialfurtherAscendingBeyondThisStart = start; 
                                 potentialfurtherAscendingBeyondThisEnd = end;
                                 System.out.println("--------------------------------------007Stored start -> end: " + potentialfurtherAscendingBeyondThisStart + "->" + potentialfurtherAscendingBeyondThisEnd);
                                 
                                 hasWrittenStoreDueTransition=true;
                            }
                        }
                    }
                        
                    if (counter==0)
                    {
                        backupStart=String.valueOf(nums[k]);
                    }
                        
                    if (counter==0 && (k==nums.length-2))
                    {
                        if (sm.isEmpty() && !isFirstOccurenceAscendingChain 
                        && !(potentialfurtherAscendingBeyondThisStart=="") 
                        && !(potentialfurtherAscendingBeyondThisEnd==""))
                        {
                            sm.add(potentialfurtherAscendingBeyondThisStart+"->"+nums[k]);
                            
                            System.out.println("--------------------1980USING STORED TO WRITE RANGE");
                            System.out.println("99943434Writing range: " + potentialfurtherAscendingBeyondThisStart + "-> " + nums[k]);
                            completeTicker(potentialfurtherAscendingBeyondThisStart,String.valueOf(nums[k]),k,lengthNums);
                            potentialfurtherAscendingBeyondThisStart="";
                            potentialfurtherAscendingBeyondThisEnd="";
                        }
                        
                        start=String.valueOf(nums[k]);
                        end = String.valueOf(nums[k+1]);
                        
                        if (!(potentialfurtherAscendingBeyondThisStart=="") 
                        && !(potentialfurtherAscendingBeyondThisEnd==""))
                        {
                            sm.add(potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                            System.out.println("--------------------001980USING STORED TO WRITE RANGE");
                            System.out.println("4343466Writing range: " + potentialfurtherAscendingBeyondThisStart + "-> " + potentialfurtherAscendingBeyondThisEnd);
                            System.out.println(sm);
                            completeTicker(potentialfurtherAscendingBeyondThisStart,potentialfurtherAscendingBeyondThisEnd,k,lengthNums);
                            potentialfurtherAscendingBeyondThisStart="";
                            potentialfurtherAscendingBeyondThisEnd="";
                            hasWrittenRepeatNumber=true;
                        }
                        
                        if (k==nums.length-2 && !hasWrittenRepeatNumber)
                        {
                            sm.add(start+"->"+end);
                            System.out.println("5Writing range: " + start + "-> " + end);
                            descendingCounter++;
                            completeTicker(start,end,k,lengthNums);
                            isFirstOccurenceAscendingChain=false;
                            isFirstOccurenceAscendingChainNoTransition =false;
                        }
                        
                        else
                        {
                            if ((potentialfurtherAscendingBeyondThisStart=="")
                            && (potentialfurtherAscendingBeyondThisEnd=="")
                            && (!hasWrittenRepeatNumber))
                            {
                                start=String.valueOf(nums[k]);
                                end=String.valueOf(nums[k+1]);
                                System.out.println("9711111Writing range: " + start + "-> " + end);
                                sm.add(start+"->" + end);
                                completeTicker(start,end,k,lengthNums);
                                break;
                            }
                            
                            if ((potentialfurtherAscendingBeyondThisStart=="")
                            && (potentialfurtherAscendingBeyondThisEnd=="")
                            && (hasWrittenRepeatNumber)
                            && (tickerCounter==tickerCounterOnPreviousRange) 
                            && tickerCounter>0)
                            {
                                start=String.valueOf(nums[k]);
                                end=String.valueOf(nums[k+1]);
                                System.out.println("1201021Writing range: " + start + "-> " + end);
                                sm.add(start+"->" + end);
                                completeTicker(start,end,k,lengthNums);
                                tickerCounterOnPreviousRange=0;
                                break;
                            }
                            
                            if (!hasWrittenRepeatNumber)
                            {
                                sm.add(start+"->"+end);
                                System.out.println("5aWriting range: " + start + "-> " + end);
                                descendingCounter++;
                                completeTicker(start,end,k,lengthNums);
                                isFirstOccurenceAscendingChain=false;
                                isFirstOccurenceAscendingChainNoTransition =false;
                            }
                        }
                      
                        if(!(potentialfurtherAscendingBeyondThisStart=="") 
                        && !(potentialfurtherAscendingBeyondThisEnd=="") 
                        && (isFirstOccurenceAscendingChain))
                        {
                            if (nums[k]!=nums[k-1])
                            {
                                sm.add(potentialfurtherAscendingBeyondThisStart+"->"+nums[k]);
                                System.out.println("--------------------2322USING STORED TO WRITE RANGE");
                                System.out.println("97052Writing range: " + potentialfurtherAscendingBeyondThisStart + "-> " + nums[k]);
                                descendingCounter=0;
                            
                                completeTicker(potentialfurtherAscendingBeyondThisStart,String.valueOf(nums[k]),k,lengthNums);
                            }
                            potentialfurtherAscendingBeyondThisStart="";
                            potentialfurtherAscendingBeyondThisEnd="";
                        }
                        
                        hasWrittenRepeatNumber=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);
                        hasStandaloneAfter=false;
                        descendingCounter++;
                        completeTicker(start,end,k,lengthNums);
                        
                    }
                    if (counter==0)
                    {
                        if (isFirstOccurenceAscendingChainNoTransition || isFirstOccurenceAscendingChain)
                        {
                            if ((potentialfurtherAscendingBeyondThisEnd=="")
                            && (potentialfurtherAscendingBeyondThisStart=="")
                            && !(hasWrittenStoreDueTransition))
                            {
                                end=String.valueOf(nums[k]);
                                sm.add(start+"->"+end);
                                System.out.println("28Writing range: " + start + "-> " + end);
                                isFirstOccurenceAscendingChain=false;
                                isFirstOccurenceAscendingChainNoTransition =false;
                                ascendingCounter++;
                                completeTicker(start,end,k,lengthNums);
                                potentialfurtherAscendingBeyondThisEnd="";
                                potentialfurtherAscendingBeyondThisStart="";
                            }
                            hasWrittenStoreDueTransition=true;
                        }
                        else
                        {
                            if (String.valueOf(nums[k+1]).equals(potentialfurtherAscendingBeyondThisStart))
                            {
                                System.out.println("123456using stored start");
                                sm.add(potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                                System.out.println("197618bWriting range: " + potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                                ascendingCounter++;
                                    
                                completeTicker(potentialfurtherAscendingBeyondThisStart,potentialfurtherAscendingBeyondThisEnd,k,lengthNums);
                                potentialfurtherAscendingBeyondThisStart="";
                                potentialfurtherAscendingBeyondThisEnd="";
                            }
                        }
                        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);
                            completeTicker(start, start,k,lengthNums);
                        }
                    }
                    
                    if (k>=1)
                    {
                        if ((nums[k]==nums[k-1])
                        && !(Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                        && !(Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
                        {
                            System.out.println("Writing Standalone: " + start);
                            sm.add(start);
                            completeTicker(start, start,k,lengthNums);
                        }
                    }
                    
                    counter++; 
                }
                else
                {
                    if (k==nums.length-2)
                    {
                        System.out.println("k=nums.length-2");
                        
                        if (temp!="")
                        {
                            sm.add(temp);
                            System.out.println("9Writing range: " + temp);
                            completeTicker(backupStart,end,k,lengthNums);
                            isFirstOccurenceAscendingChain=false;
                            isFirstOccurenceAscendingChainNoTransition =false;
                        }
                        
                        if (counter==0)
                        {
                            if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                            {
                                System.out.println("next number descending (difference)");
                                start=String.valueOf(nums[k]);
                                end = String.valueOf(nums[k+1]);
                                sm.add(start+"->"+end);
                                completeTicker(start,end,k,lengthNums);
                                System.out.println("7Writing range: " + start + "-> " + end);
                                isFirstOccurenceAscendingChain=false;
                                isFirstOccurenceAscendingChainNoTransition =false;
                            }
                            else
                            {
                                end = String.valueOf(nums[k]);
                            
                                if (isFirstOccurenceAscendingChainNoTransition || isFirstOccurenceAscendingChain)
                                {
                                    if (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                                    {   
                                        if (!(potentialfurtherAscendingBeyondThisStart=="") 
                                        && !(potentialfurtherAscendingBeyondThisEnd=="")
                                        && (nums[k]==nums[k-1]))
                                        {
                                            sm.add(potentialfurtherAscendingBeyondThisStart+"->"+String.valueOf(nums[k]));
                                            System.out.println("--------------------47171USING STORED TO WRITE RANGE");
                                            System.out.println("41717Writing range: " + potentialfurtherAscendingBeyondThisStart + "-> " + nums[k]);
                                            completeTicker(potentialfurtherAscendingBeyondThisStart,String.valueOf(nums[k]),k,lengthNums);
                                        }
                                        else
                                        {
                                            potentialfurtherAscendingBeyondThisStart="";
                                            potentialfurtherAscendingBeyondThisEnd="";
                                        }
                                        
                                        if (potentialfurtherAscendingBeyondThisEnd!="" && potentialfurtherAscendingBeyondThisEnd!="")
                                        {
                                            System.out.println("091090using stored start");
                                            sm.add(potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                                            System.out.println("091090aWriting range: " + potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                                        
                                            completeTicker(potentialfurtherAscendingBeyondThisStart,potentialfurtherAscendingBeyondThisEnd,k,lengthNums);
                                            potentialfurtherAscendingBeyondThisStart="";
                                            potentialfurtherAscendingBeyondThisEnd="";
                                        }
                                        
                                        System.out.println("next number ascending (difference)");
                                        end=String.valueOf(nums[k+1]);
                                        sm.add(start+"->"+end);
                                                   
                                        System.out.println("35Writing range: " + start + "-> " + end);
                                        ascendingCounter++;
                                        completeTicker(start,end,k,lengthNums);
                                        hasNotWrittenLastNumber=false;
                                        isFirstOccurenceAscendingChain=false;
                                        isFirstOccurenceAscendingChainNoTransition =false;
                                        
                                        //This is not considered a bug, it was realised it reached this area of code
                                        //when it processed last part of the data for certain test cases,
                                        //hence increasing the counter had no difference..
                                        ascendingCounter++;
                                    }
                                    else
                                    {
                                        end=String.valueOf(nums[k]);
                                        sm.add(start+"->"+end);
                                        System.out.println("27Writing range: " + start + "-> " + end);
                                        completeTicker(start,end,k,lengthNums);
                                    }
                                }     
                                else 
                                {
                                    if (temp=="")
                                    {
                                        if (nums.length==2)
                                        {
                                            if ((Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon) 
                                            || (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon))
                                            {
                                                System.out.println("next number ascending(difference) AND/OR descending (difference)");
                                                start=String.valueOf(nums[k]);
                                                end=String.valueOf(nums[k+1]);
                                                sm.add(start+"->"+end);
                                                System.out.println("2678Writing range, only two ascending numbers in array: " + start + "-> " + end);
                                                completeTicker(start, end,k,lengthNums);
                                                
                                                break;
                                            }
                                            else
                                            {
                                                System.out.println("next number NOT within difference");
                                                start=String.valueOf(nums[k]);
                                                
                                                sm.add(start);    
                                                System.out.println("234Writing Standalone: " + start);
                                                completeTicker(start, start,k,lengthNums);
                                                
                                                start=String.valueOf(nums[k+1]);
                                                sm.add(start);
                                                    
                                                System.out.println("2348Writing Standalone: " + start);
                                                completeTicker(start, start,k,lengthNums);
                                                    
                                                break;
                                            }
                                        }
                                        
                                        if (Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)
                                        {
                                            System.out.println("previous number descending (difference)");
                                                
                                            if (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                                            {
                                                System.out.println("next number ascending (difference)");
                                                ascendingCounter++;
                                                
                                                if (writtenPrevious)
                                                {
                                                    start=potentialfurtherAscendingBeyondThisStart;
                                                    end=String.valueOf(nums[k+1]);
                                                    sm.add(start+"->"+end);
                                                        
                                                    System.out.println("6098Writing range: " + start + "-> " + end);
                                                    completeTicker(start, end,k,lengthNums);
                                                }
                                                else
                                                {
                                                    start=String.valueOf(nums[k-1]);
                                                    end=String.valueOf(nums[k+1]);
                                                    sm.add(start+"->"+end);
                                                    System.out.println("9876Writing range: " + start + "-> " + end);
                                                    completeTicker(start,end,k,lengthNums);
                                    
                                                    potentialfurtherAscendingBeyondThisStart="";
                                                    potentialfurtherAscendingBeyondThisStart="";
                                                }
                                                writtenPrevious=false;
                                            }
                                            else
                                            {
                                                if (writtenPrevious)
                                                {
                                                    System.out.println("6111using stored start");
                                                    sm.add(potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                                                    System.out.println("197618aWriting range: " + potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                                                    writtenPrevious=false;
                                                    completeTicker(potentialfurtherAscendingBeyondThisStart,potentialfurtherAscendingBeyondThisEnd,k,lengthNums);
                                                    potentialfurtherAscendingBeyondThisStart="";
                                                    potentialfurtherAscendingBeyondThisEnd="";
                                                }
                                                
                                                if (k==1 && nums.length>=3)
                                                {
                                                    start=String.valueOf(nums[k-1]);
                                                    end=String.valueOf(nums[k]);
                                                    sm.add(start+"->"+end);    
                                                
                                                    System.out.println("00000Writing range: " + start+"->"+end);
                                                    completeTicker(start,end,k,lengthNums);
                                                }
                                                
                                                if (k+1==nums.length-1)
                                                {
                                                    start=String.valueOf(nums[k+1]);
                                                    sm.add(start);
                                                    System.out.println("0241Writing Standalone: " + start);
                                                    System.out.println("The last number in the array");
                                                    completeTicker(start, start,k,lengthNums);
                                                        
                                                    break;
                                                }
                                            }
                                        }
                                        else
                                        {
                                            if (!(Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon))
                                            {
                                                System.out.println("previous number not descending (difference)");
                                                System.out.println("next number ascending (difference)");
                                                start=String.valueOf(nums[k]);
                                                sm.add(start);
                                                System.out.println("009Writing Standalone: " + start);
                                                completeTicker(start, start,k,lengthNums);
                                            
                                                start=String.valueOf(nums[k+1]);
                                                sm.add(start);
                                                System.out.println("0089Writing Standalone: " + start);
                                                completeTicker(start, start,k,lengthNums);
                                            }
                                            else
                                            {
                                                System.out.println("previous number (not within difference), next number (difference)");
                                                
                                                if(!(potentialfurtherAscendingBeyondThisStart=="") 
                                                && !(potentialfurtherAscendingBeyondThisEnd=="") 
                                                && (isFirstOccurenceAscendingChain))
                                                {
                                                    sm.add(potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                                                    System.out.println("--------------------2322USING STORED");
                                                    System.out.println("2025Writing range: " + potentialfurtherAscendingBeyondThisStart + "-> " + potentialfurtherAscendingBeyondThisEnd);
                                                }
                                                start=String.valueOf(nums[k]);
                                                end=String.valueOf(nums[k+1]);
                                                sm.add(start+"->"+end);
                                                    
                                                System.out.println("1992Writing range: " + start + "-> " + end);
                                                ascendingCounter++;
                                                completeTicker(start,end,k,lengthNums);
                                                isFirstOccurenceAscendingChain=false;
                                                isFirstOccurenceAscendingChainNoTransition=false;
                                            }
                                        }
                                        combineMerge=true;
                                    }
                                }
                                
                                if (hasNotWrittenLastNumber && !combineMerge)
                                {
                                    start=String.valueOf(nums[k+1]);
                                    System.out.println("4Writing Standalone: " + start);
                                    sm.add(start);
                                    completeTicker(start, start,k,lengthNums);
                                    hasNotWrittenLastNumber=false;
                                }
                            }
                        }
                        else   
                        {
                            if (!(potentialfurtherAscendingBeyondThisEnd.equals("")) && !(potentialfurtherAscendingBeyondThisStart.equals("")))
                            {
                                if ( ((Math.abs(nums[k] - Float.valueOf(potentialfurtherAscendingBeyondThisEnd) + difference)) <epsilon))
                                {
                                    System.out.println("7using stored start--------------------------------------------------------------");
                                    start=potentialfurtherAscendingBeyondThisStart;
                                    
                                    sm.add(start+"->"+String.valueOf(nums[k]));
                                    System.out.println("3aWriting range: " + start + "-> " + end);
                                    completeTicker(start,end,k,lengthNums);
                                }
                                else
                                {
                                    System.out.println("7using stored start--------------------------------------------------------------");
                                    start=potentialfurtherAscendingBeyondThisStart;
                                    end=String.valueOf(nums[k]);
                                    sm.add(start+"->"+end);
                                    System.out.println("3Writing range: " + start + "-> " + end);
                                    completeTicker(start,end,k,lengthNums);
                                }
                                potentialfurtherAscendingBeyondThisStart="";
                                potentialfurtherAscendingBeyondThisEnd="";
                            }
                            else
                            {
                                if (nums[k]!=nums[k-1])
                                {
                                    start=String.valueOf(nums[k-1]);
                                    end=String.valueOf(nums[k]);
                                    sm.add(start+"->"+end);
                                    System.out.println("3mWriting range: " + start + "-> " + end);
                                    completeTicker(start,end,k,lengthNums);
                                }
                            }
                            
                            if ((Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                            ||   (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
                            {
                                System.out.println("ascending/descending next number (diffference)");
                                start=String.valueOf(nums[k]);
                                end=String.valueOf(nums[k+1]);
                                sm.add(start+"->"+end);
                                System.out.println("49Writing range: " + start + "-> " + end);
                                completeTicker(start,end,k,lengthNums);
                                isFirstOccurenceAscendingChain=false;
                                isFirstOccurenceAscendingChainNoTransition =false;
                            }
                            else
                            {
                                System.out.println("Next number not within difference");
                                start=String.valueOf(nums[k+1]);
                                sm.add(start);
                                System.out.println("599Writing standalone: " + start);
                                completeTicker(start, start,k,lengthNums);
                            }
                        }
                    }
                    else
                    {
                        if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                        {
                            System.out.println("next number descending (difference)");
                            end=String.valueOf(nums[k+1]);
                        }
                        else
                        {
                            System.out.println("1next number not descending (difference)");
                            end=String.valueOf(nums[k]);
                        }
                        
                        System.out.println("This is counter at the moment:  " + counter);
                        
                        if (counter==0)
                        {
                            if(k==0)
                            {
                                if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                                {
                                    System.out.println("next number descending (difference)");
                                    
                                    if (writtenPrevious)
                                    {
                                        System.out.println("7777using stored start");
                                        sm.add(potentialfurtherAscendingBeyondThisStart+"->"+end);
                                        System.out.println("197617Writing range: " + start+"->"+end);
                                        completeTicker(potentialfurtherAscendingBeyondThisStart,end,k,lengthNums);
                                        writtenPrevious=false;
                                        potentialfurtherAscendingBeyondThisStart="";
                                        potentialfurtherAscendingBeyondThisEnd="";
                                    }
                                    start=String.valueOf(nums[k]);
                                    counter++;
                                }
                                else
                                {
                                    if (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                                    {
                                        System.out.println("next number ascending (difference)");
                                        ascendingCounter++;
                                        start=String.valueOf(nums[k]);
                                        end=String.valueOf(nums[k+1]);
                                        
                                        potentialfurtherAscendingBeyondThisStart = start; 
                                        potentialfurtherAscendingBeyondThisEnd = end;
                                        System.out.println("--------------------------------------0Stored start -> end: " + start + "->" + end);
                                        
                                        isFirstOccurenceAscendingChain=false;
                                        isFirstOccurenceAscendingChainNoTransition =false;
                                    }
                                    else
                                    {
                                        System.out.println("2next number NOT within difference");
                                        System.out.println("5Writing standalone: " + start);
                                        sm.add(start);
                                        completeTicker(start, start,k,lengthNums);
                                    }
                                }
                            }
                            else
                            {
                                if (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                                {
                                    System.out.println("next number descending (difference)");
                                    if (temp=="")
                                    {
                                        if (Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)
                                        {
                                            System.out.println("previous number descending (difference)");
                                            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
                                {
                                    System.out.println("2next number not descending (difference)");
                                        
                                    if(temp!="")
                                    {
                                        sm.add(temp);
                                        System.out.println("8Writing range: " + temp);
                                        temp="";
                                        backupStart="";
                                        isFirstOccurenceAscendingChain=false;
                                        isFirstOccurenceAscendingChainNoTransition =false;
                                    }
                                    else
                                    {
                                        if ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon) 
                                        || (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon))
                                        {
                                            System.out.println("previous number descending(difference) AND/OR next number ascending (difference)");
                                            end = String.valueOf(nums[k]);
                                            
                                            if (nums[k]==nums[k-1] && !hasWrittenRepeatNumber)
                                            {
                                                System.out.println("Previous number same as current");
                                                start = String.valueOf(nums[k-1]);
                                                sm.add(start);
                                                System.out.println("6Writing Standalone: " + start);
                                                completeTicker(start, start,k,lengthNums);
                                            }
                                            
                                            hasWrittenRepeatNumber=false;
                                                
                                            if  (Math.abs(nums[k] - (nums[k+1] - difference))<epsilon)
                                            {
                                                System.out.println("Next number ascending");
                                                ascendingCounter++;
                                                
                                                if (!isFirstOccurenceAscendingChainNoTransition)
                                                {
                                                    start=String.valueOf(nums[k]);
                                                    
                                                    isFirstOccurenceAscendingChainNoTransition=true;
                                                }
                                                    
                                                if (isFirstOccurenceAscendingChainNoTransition 
                                                && (potentialfurtherAscendingBeyondThisStart.equals("")) 
                                                && (potentialfurtherAscendingBeyondThisEnd.equals("")))
                                                {
                                                    start=String.valueOf(nums[k]);
                                                    end=String.valueOf(nums[k+1]);
                                        
                                                    potentialfurtherAscendingBeyondThisStart = start; 
                                                    potentialfurtherAscendingBeyondThisEnd = end;
                                                   
                                                    System.out.println("--------------------------------------22Stored start -> end: " + start + "->" + end);
                                                }
                                                    
                                                if ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon) 
                                                && (Math.abs(nums[k] - (nums[k+1] - difference))<epsilon))
                                                {
                                                    System.out.println("Previous number descending (difference) AND next number ascending (difference)");
                                                        
                                                    if (!isFirstOccurenceAscendingChain)
                                                    {
                                                        start=String.valueOf(nums[k-1]);
                                                        isFirstOccurenceAscendingChain=true;
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                System.out.println("next item is NOT ascending(difference)");
                                                
                                                if (!potentialfurtherAscendingBeyondThisStart.equals("") 
                                                && !(potentialfurtherAscendingBeyondThisEnd.equals("")))
                                                {
                                                    System.out.println("using stored start");
                                                    sm.add(start+"->"+end);
                                                    System.out.println("197619Writing range: " + start+"->"+end);
                                                    ascendingCounter++;
                                                    completeTicker(start,end,k,lengthNums);
                                                }
                                                else
                                                {
                                                    sm.add(start+"->"+end);
                                                    System.out.println("1541Writing range: " + start+"->"+end);
                                                    completeTicker(start,end,k,lengthNums);
                                                }
                                                potentialfurtherAscendingBeyondThisEnd="";
                                                potentialfurtherAscendingBeyondThisStart="";
                                                isFirstOccurenceAscendingChain=false;
                                                isFirstOccurenceAscendingChainNoTransition=false;
                                                isFirstOccurenceAscendingChain=false;
                                                isFirstOccurenceAscendingChainNoTransition =false;
                                            }
                                        }
                                        else  
                                        {
                                            System.out.println("previous number ascending (difference) OR next number descending(difference)");
                                            
                                            if (potentialfurtherAscendingBeyondThisStart!="" && potentialfurtherAscendingBeyondThisEnd!="")
                                            {
                                                System.out.println("using stored start");
                                                sm.add(potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
System.out.println("888881Writing range: " +potentialfurtherAscendingBeyondThisStart+"->"+potentialfurtherAscendingBeyondThisEnd);
                                                potentialfurtherAscendingBeyondThisEnd="";
                                                potentialfurtherAscendingBeyondThisStart="";
                                            }
                                            else
                                            {
                                                start = String.valueOf(nums[k]);
                                                sm.add(start);
                                                System.out.println("6Writing Standalone: " + start);
                                                completeTicker(start, start,k,lengthNums);
                                                tickerCounterOnPreviousRange=tickerCounter;
                                                isFirstOccurenceAscendingChain=false;
                                                isFirstOccurenceAscendingChainNoTransition=false;
                                            }
                                        }
                                    }  
                                }
                            }
                        }
                        else                        
                        {
                            System.out.println("counter is not zero");                         
                                
                            if ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)  
                            && (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
                            {
                                System.out.println("next number descending (difference) AND previous number descending (difference)");
                                end=String.valueOf(nums[k]);
                                sm.add(backupStart+"->"+end);
                                System.out.println("10Writing range: " + backupStart+"->"+end);
                                hasTransition=true;
                                System.out.println(" 12hasTransition set to true");
                                transitionNumber=String.valueOf(nums[k]);
                                System.out.println("1Transition number: " + transitionNumber + " descending(difference) on either side");
                                
                                isFirstOccurenceAscendingChain=false;
                                isFirstOccurenceAscendingChainNoTransition =false;
                            }
                            
                            if ((Math.abs(nums[k] - (nums[k-1] - difference)) <epsilon)  
                            && (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon))
                            {
                                transitionNumber=String.valueOf(nums[k]);
                                System.out.println("Transition number: " + transitionNumber + " ascending(difference) on either side");
                                System.out.println("next number ascending (difference) AND previous number descending (difference");
                            }
                            
                            if (!hasTransition)
                            {
                                if (temp!="")
                                {
                                    //System.out.println("TEMP!=blank");
                                    end=String.valueOf(nums[k+1]);
                                    sm.add(start+"->"+end);
                                    System.out.println("-------------------Writing range: " + start+"->"+end);
                                }
                                else
                                {
                                    //System.out.println("COUNTER VALUE: " + counter);
                                                     
                                    if ((Math.abs(nums[k] - (nums[k-1] - difference)) <epsilon) 
                                    && (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon))
                                    {
                                        System.out.println("previous number ascending (difference) AND next number ascending (difference)");
                                        
                                        
                                        if (potentialfurtherAscendingBeyondThisStart!="" && potentialfurtherAscendingBeyondThisEnd!="")
                                        {
                                            System.out.println("--------------------9999 STORED TO WRITE RANGE");
                                            System.out.println("3121Writing range: " + potentialfurtherAscendingBeyondThisStart + "-> " + end);
                                            sm.add(potentialfurtherAscendingBeyondThisStart+"->"+end);
                                            completeTicker(potentialfurtherAscendingBeyondThisStart,end,k,lengthNums);
                                            end=String.valueOf(nums[k+1]);
                                            start=String.valueOf(nums[k]);
                                            potentialfurtherAscendingBeyondThisStart="";
                                            potentialfurtherAscendingBeyondThisEnd="";
                                        }
                                        
                                        ascendingCounter++;
                                        
                                        potentialfurtherAscendingBeyondThisStart=String.valueOf(nums[k]);
                                        potentialfurtherAscendingBeyondThisEnd=String.valueOf(nums[k+1]);
                                        
                                        System.out.println("--------------------------------------1Stored start -> end: " + start + "->" + end);
                                            
                                        writtenPrevious=true;
                                    }
                                    else
                                    {
                                        System.out.println("previous number AND/OR next number not ascending(difference)");
                                       
                                       if ((potentialfurtherAscendingBeyondThisStart!="") 
                                       && (potentialfurtherAscendingBeyondThisEnd!=""))
                                       {
                                            if ((Math.abs(nums[k] - (nums[k-1] - difference)) <epsilon) 
                                            || (Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)
                                            && !(nums[k]==nums[k-1]))
                                            {
                                                System.out.println("--------------------55555USING STORED TO WRITE RANGE");
                                                System.out.println("2aWriting range: " + potentialfurtherAscendingBeyondThisStart + "-> " + String.valueOf(nums[k]));
                                                sm.add(potentialfurtherAscendingBeyondThisStart + "-> " + String.valueOf(nums[k]));
                                                completeTicker(potentialfurtherAscendingBeyondThisStart,String.valueOf(nums[k]),k,lengthNums);
                                                potentialfurtherAscendingBeyondThisStart="";
                                                potentialfurtherAscendingBeyondThisEnd="";
                                            }  
                                        }
                                        else
                                        {
                                            if ((!(Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon) 
                                            && !(Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon)
                                            && ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon)
                                            || (Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)))
                                            && !hasWrittenRepeatNumber)
                                            {
                                                System.out.println("2bWriting range: " + start + "-> " + end);
                                                sm.add(start+"->"+end);
                                                completeTicker(start,end,k,lengthNums);
                                            }
                                            
                                            else
                                            {
                                                if ((Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon) 
                                                || (Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
                                                {
                                                    ascendingCounter++;
                                                
                                                    start=String.valueOf(nums[k]);
                                                    end=String.valueOf(nums[k+1]);
                                                    potentialfurtherAscendingBeyondThisStart = start; 
                                                    potentialfurtherAscendingBeyondThisEnd = end;
                                                    System.out.println("--------------------------------------12cStored start -> end: " + potentialfurtherAscendingBeyondThisStart + "->" + potentialfurtherAscendingBeyondThisEnd);
                                                }
                                            }
                                            
                                            if ((nums[k]==nums[k-1])
                                            &&  !(Math.abs(nums[k] - (nums[k+1] - difference)) <epsilon)
                                            && !(Math.abs(nums[k] - (nums[k+1] + difference)) <epsilon))
                                            {
                                                start = String.valueOf(nums[k]);
                                                sm.add(start);
                                                System.out.println("8888888888Writing Standalone: " + start);
                                                completeTicker(start, start,k,lengthNums);
                                            }    
                                        }
                                    }
                                    isFirstOccurenceAscendingChain=false;   
                                    isFirstOccurenceAscendingChainNoTransition =false;
                                }
                            }
                            counter=0;
                            temp="";
                            backupStart="";
                            hasTransition=false;
                        }
                    }
                }
            }
            else
            {
                System.out.println("\nCHECKING: " + nums[k] + " with " + nums[k+1]);
                System.out.println("REPEAT NUMBER");
                
                                if (nums.length==2)
                                {
                                    System.out.println("\nTICKER: " + Arrays.toString(nums));
System.out.println(Arrays.toString(nums));
                                    standaloneCount=2;
                                    tickerCounter=standaloneCount;
                                    System.out.println("Standalone numbers: " + standaloneCount + "   Ascending chains: " + ascendingChainsComplete + "   Descending chains: " + descendingChainsComplete + "      TOTAL: " + tickerCounter);
                                    System.out.println("Transition events: " + transitionEvents);

                                    // Ensure ChatGPT ticker + plateau breakdown is printed too (repeat standalones case)
                                    TickerResult tickerV2_local = buildTickerV2(nums, lengthNums);
                                    lastChatgptTickerV2 = tickerV2_local;
                                    printChatgptBreakdown(tickerV2_local);

                                    System.exit(0);
                                }

                
                if (k==(nums.length-2))
                {
                    if ((Math.abs(nums[k] - (nums[k-1] - difference)) <epsilon) 
                    && (potentialfurtherAscendingBeyondThisStart.equals(""))  
                    && (potentialfurtherAscendingBeyondThisEnd.equals("")))
                    {
                        System.out.println("Previous number ascending (difference)");
                        start=String.valueOf(nums[k-1]);
                        end=String.valueOf(nums[k]);
                                
                        System.out.println("97053Writing range: " + start + "-> " + end);
                        sm.add(start+"->"+end);
                        isPrevNumAscending=true;
                    }
                    
                    if (!potentialfurtherAscendingBeyondThisStart.equals("") 
                    && !(potentialfurtherAscendingBeyondThisEnd.equals("")))
                    {
                        sm.add(potentialfurtherAscendingBeyondThisStart+"->"+nums[k]);
                        System.out.println("--------------------23229USING STORED TO WRITE RANGE");
                        System.out.println("9705Writing range: " + potentialfurtherAscendingBeyondThisStart + "-> " + nums[k]);
                        completeTicker(potentialfurtherAscendingBeyondThisStart,potentialfurtherAscendingBeyondThisEnd,k,lengthNums);
                        potentialfurtherAscendingBeyondThisStart="";
                        potentialfurtherAscendingBeyondThisEnd="";
                        System.out.println("CURRENT LIST: " + sm);
                    }
                    else
                    {
                        start = String.valueOf(nums[k]);
                        sm.add(start);
                        System.out.println("07774544Writing Standalone: " + start);
                        completeTicker(start, start,k,lengthNums);
                    }
                }
                
                start = String.valueOf(nums[k]);
                    
                if (potentialfurtherAscendingBeyondThisStart=="" && potentialfurtherAscendingBeyondThisEnd=="")
                {
                    if (k==0)
                    {
                        if(nums[k]==nums[k+1])
                        {
                            sm.add(start);
                            System.out.println("066666Writing Standalone: " + start);
                            completeTicker(start, start,k,lengthNums);
                            hasWrittenRepeatNumber=true;
                        }
                    }
                        
                    if (k>0)
                    {
                        if (nums[k]==nums[k-1] || nums[k]==nums[k+1])
                        {
                            sm.add(start);
                            System.out.println("019238475Writing Standalone: " + start);
                            completeTicker(start, start,k,lengthNums);
                            hasWrittenRepeatNumber=true;
                            tickerCounterOnPreviousRange=tickerCounter;
                        }
                    }
                }
                else
                {
                    if((Math.abs(nums[k] - (nums[k-1] - difference)) <epsilon)
                    || (Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon))
                    {
                        if ((Math.abs(nums[k] - (nums[k-1] + difference)) <epsilon))
                        {
                            ascendingCounter++;
                        }
                            
                        sm.add(potentialfurtherAscendingBeyondThisStart+"->"+nums[k]);
                        System.out.println("--------------------23229USING STORED TO WRITE RANGE");
                        System.out.println("-1010Writing range: " + potentialfurtherAscendingBeyondThisStart + "-> " + nums[k]);
                        completeTicker(potentialfurtherAscendingBeyondThisStart,String.valueOf(nums[k]),k,lengthNums);
                        hasWrittenRepeatNumber=true;
                        tickerCounterOnPreviousRange=tickerCounter;
                        
                        potentialfurtherAscendingBeyondThisStart="";
                        potentialfurtherAscendingBeyondThisEnd="";
                        
                        if (String.valueOf(nums[k+1]).equals(potentialfurtherAscendingBeyondThisEnd))
                        {
                            sm.add(start);
                            System.out.println("0690690695Writing Standalone: " + start);
                            completeTicker(start, start,k,lengthNums);
                        }
                    }
                    else
                    {
                        standaloneTemp = start;
                    }
                }
            }  
        }
        // --------------------CHATGPT---------------------
        // BUGFIX: Deterministic ticker (fixes magnitude for multi-entry edge cases)
        TickerResult tickerV2 = buildTickerV2(nums, lengthNums);
        lastChatgptTickerV2 = tickerV2;
        
                printChatgptBreakdown(tickerV2);
// -----------------------END CHATGPT-------------------
        return sm;
    }

    // --------------------CHATGPT---------------------
    // Deterministic ticker builder from raw nums (shape-only) + segment metadata
    // so we can compare against your magnitude/reset ticker in main.

    public static final class SegmentInfo {
        public final char type;      // 'S', 'A', 'D'
        public final int count;      // number of elements in this segment
        public final int startIndex; // inclusive
        public final int endIndex;   // inclusive
        public final boolean fromPlateau; // true only for 'S' segments created from repeat runs

        public SegmentInfo(char type, int count, int startIndex, int endIndex, boolean fromPlateau) {
            this.type = type;
            this.count = count;
            this.startIndex = startIndex;
            this.endIndex = endIndex;
            this.fromPlateau = fromPlateau;
        }
    }

    public static final class PlateauInfo {
        public final int startIndex; // k where repeat run begins
        public final int size;       // run length
        public final float value;
        public final String label;   // e.g. "At start of the chain", "In between A-D chain"

        PlateauInfo(int startIndex, int size, float value, String label) {
            this.startIndex = startIndex;
            this.size = size;
            this.value = value;
            this.label = label;
        }
    }

    private static final class Token {
        public final char type;
        public final int count;

        Token(char type, int count) {
            this.type = type;
            this.count = count;
        }

        String display() {
            if (type == 'S') {
                return (count == 1) ? "S" : ("S(" + count + ")");
            }
            return type + "(" + count + ")";
        }
    }

    public static final class TickerResult {
        public final String ticker;
        public final List<String> summaryRanges;
        public final List<SegmentInfo> segments;      // excludes '-' and '*'
        public final List<PlateauInfo> plateaus;      // plateau runs (repeat numbers)
        public final Map<String, int[]> plateauTotals; // label -> [countOfPlateaus, sumOfOccurrences]

        public final int standaloneCount, ascendingChains, descendingChains, plateauCount, totalSegments, transitionEvents;

        public TickerResult(String ticker,
                            List<String> summaryRanges,
                            List<SegmentInfo> segments,
                            List<PlateauInfo> plateaus,
                            Map<String, int[]> plateauTotals,
                            int standaloneCount,
                            int ascendingChains,
                            int descendingChains,
                            int plateauCount,
                            int totalSegments,
                            int transitionEvents) {
            this.ticker = ticker;
            this.summaryRanges = summaryRanges;
            this.segments = segments;
            this.plateaus = plateaus;
            this.plateauTotals = plateauTotals;
            this.standaloneCount = standaloneCount;
            this.ascendingChains = ascendingChains;
            this.descendingChains = descendingChains;
            this.plateauCount = plateauCount;
            this.totalSegments = totalSegments;
            this.transitionEvents = transitionEvents;
        }
    }

    private static boolean approxStep(float diff, float step, float eps) {
        return Math.abs(diff - step) <= eps;
    }
    private static boolean approxZero(float diff, float eps) {
        return Math.abs(diff) <= eps;
    }

    private static List<Token> tokensFromSegments(List<SegmentInfo> segments) {
        List<Token> out = new ArrayList<>();
        for (SegmentInfo s : segments) out.add(new Token(s.type, s.count));
        return out;
    }

    // Parses a ticker into tokens (ignores '*' markers, '-' separators, and whitespace).
    // Examples:
    //   "SSA(5)D(3)" -> [Sx2, A(5), D(3)]
    //   "D(3)A(2)A(4)-D(3)" -> [D(3), A(2), A(4), D(3)]
    private static List<Token> parseTickerTokens(String ticker) {
        List<Token> tokens = new ArrayList<>();
        if (ticker == null) return tokens;

        int i = 0;
        while (i < ticker.length()) {
            char c = ticker.charAt(i);

            if (Character.isWhitespace(c) || c == '*' || c == '-') { i++; continue; }
            if (!Character.isLetter(c)) { i++; continue; }

            char type = c;

            // A(n)/D(n)/etc
            if (i + 1 < ticker.length() && ticker.charAt(i + 1) == '(') {
                int j = i + 2;
                int val = 0;
                boolean any = false;
                while (j < ticker.length() && Character.isDigit(ticker.charAt(j))) {
                    any = true;
                    val = val * 10 + (ticker.charAt(j) - '0');
                    j++;
                }
                // consume ')'
                while (j < ticker.length() && ticker.charAt(j) != ')') j++;
                if (j < ticker.length() && ticker.charAt(j) == ')') j++;

                tokens.add(new Token(type, any ? val : 1));
                i = j;
                continue;
            }

            // Repeated letter runs, e.g. "SSS"
            int run = 1;
            int j = i + 1;
            while (j < ticker.length() && ticker.charAt(j) == type) {
                run++;
                j++;
            }
            tokens.add(new Token(type, run));
            i = j;
        }
        return tokens;
    }

// --------------------CHATGPT---------------------
// Normalizes a ticker string for comparison:
//  - strips whitespace, '-' separators, and plateau '*' markers
//  - inserts a space between a repeated letter and the start of a parenthesized token of the same letter
//    so that patterns like "SS(2)" become "S S(2)" (prevents losing the "(2)" during parsing).
private static String normalizeTickerForComparison(String ticker) {
    if (ticker == null) return "";
    StringBuilder out = new StringBuilder();
    int n = ticker.length();
    for (int i = 0; i < n; i++) {
        char c = ticker.charAt(i);
        if (Character.isWhitespace(c) || c == '*' || c == '-') continue;

        // If we see pattern: X X (  -> insert a space between the two X's
        if (Character.isLetter(c) && i + 2 < n) {
            char c1 = ticker.charAt(i + 1);
            char c2 = ticker.charAt(i + 2);
            if (c1 == c && c2 == '(') {
                out.append(c);
                out.append(' ');
                continue; // next loop will process the second letter normally
            }
        }
        out.append(c);
    }
    return out.toString();
}

// Merges adjacent same-type tokens (e.g., S + S(2) -> S(3)).
private static List<Token> mergeAdjacentSameType(List<Token> in) {
    List<Token> out = new ArrayList<>();
    if (in == null) return out;
    for (Token t : in) {
        if (t == null) continue;
        if (out.isEmpty()) {
            out.add(t);
        } else {
            Token last = out.get(out.size() - 1);
            if (last.type == t.type) {
                out.set(out.size() - 1, new Token(last.type, last.count + t.count));
            } else {
                out.add(t);
            }
        }
    }
    return out;
}
// -----------------------END CHATGPT-------------------

    private static String formatTokensWithHighlights(List<Token> tokens, Set<Integer> highlightIndices) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < tokens.size(); i++) {
            String part = tokens.get(i).display();
            // NOTE: We use <<< >>> for mismatch highlighting to avoid confusion with plateau '*' markers.
            if (highlightIndices != null && highlightIndices.contains(i)) part = "<<<" + part + ">>>";
            if (i > 0) sb.append(" ");
            sb.append(part);
        }
        return sb.toString();
    }

    // Called from main() AFTER your ticker prints.
    // Prints "Tickers consistent" or a detailed mismatch summary and highlights ALL mismatching segments in the chain.
    private static void printTickerConsistency(String amitTicker, TickerResult chatgpt, int lengthNums) {
        // For reliable comparisons, normalize both tickers for alignment:
        //  - ignore plateau '*' markers and '-' separators (display-only)
        //  - avoid accidental parsing of patterns like "SS(2)" into a single run token
        //  - merge adjacent same-type tokens so "S" + "S(2)" becomes "S(3)"
        // Keep the pre-merge tokenization too (useful for alignment notes like: S(3)*S(4) ~= S(7)).
        List<Token> yourTokensSplit = parseTickerTokens(normalizeTickerForComparison(amitTicker));
        List<Token> chatTokensSplit = parseTickerTokens(normalizeTickerForComparison(chatgpt.ticker));

        List<Token> yourTokens = mergeAdjacentSameType(yourTokensSplit);
        List<Token> chatTokens = mergeAdjacentSameType(chatTokensSplit);
int maxLen = Math.max(yourTokens.size(), chatTokens.size());
        List<Integer> mismatches = new ArrayList<>();

        for (int i = 0; i < maxLen; i++) {
            if (i >= yourTokens.size() || i >= chatTokens.size()) {
                mismatches.add(i);
                continue;
            }
            Token yt = yourTokens.get(i);
            Token ct = chatTokens.get(i);
            // If both sides agree this is an S-type segment, differences in S-run length are often
            // just grouping/coverage artifacts (especially after earlier A/D off-by-one effects).
            // We treat these as non-actionable for mismatch reporting to reduce false positives.
            if (yt.type == 'S' && ct.type == 'S') {
                continue;
            }
            if (yt.type != ct.type || yt.count != ct.count) {
                mismatches.add(i);
            }
        }

        if (mismatches.isEmpty()) {
            System.out.println("Tickers consistent");
            return;
        }

        System.out.println("Inconsistent ticker");
        System.out.println("Differences found: " + mismatches.size());

        Set<Integer> mismatchSet = new HashSet<>(mismatches);

        // Print the full chains with ALL mismatching segments highlighted
        System.out.println("Your ticker:");
        System.out.println(formatTokensWithHighlights(yourTokens, mismatchSet));

        System.out.println("ChatGPT ticker:");
        System.out.println(formatTokensWithHighlights(chatTokens, mismatchSet));

        // Print per-mismatch index ranges (k start/end) for clarity
        System.out.println("Mismatch details (segment index -> start-end index):");

        int subtotalTrueBehavioral = 0;
        int subtotalPlateauRelated = 0;
        int subtotalUnknown = 0;

        // --------------------CHATGPT---------------------
        // Extra compact summary of true-behavior mismatches (Option A style)
        int tbAscMagnitude = 0;
        int tbDescMagnitude = 0;
        int tbSegmentTypeMismatch = 0;     // tickers disagreed on A/D/S classification
        int tbADvsSMismatch = 0;           // A/D vs S
        int tbAvsDMismatch = 0;            // A vs D
        int tbMissingTokenMismatch = 0;
        int tbDeltaA = 0;                  // sum of (ChatGPT - Amit) for A mismatches
        int tbDeltaD = 0;                  // sum of (ChatGPT - Amit) for D mismatches
        int tbMinIndex = Integer.MAX_VALUE;
        int tbMaxIndex = -1;
        // --------------------END CHATGPT-------------------

        for (int mi : mismatches) {
            String yourTok = (mi < yourTokens.size()) ? yourTokens.get(mi).display() : "[missing]";
            String chatTok = (mi < chatTokens.size()) ? chatTokens.get(mi).display() : "[missing]";

            int yourStartRaw = tokenStartIndexFromCounts(yourTokens, mi);
            int yourStart = Math.min(lengthNums - 1, Math.max(0, yourStartRaw));
            int yourEnd = (mi < yourTokens.size())
                    ? Math.min(lengthNums - 1, yourStartRaw + yourTokens.get(mi).count - 1)
                    : -1;
            if (yourEnd < yourStart) yourEnd = yourStart;

            int chatStartRaw = tokenStartIndexFromCounts(chatTokens, mi);
            int chatStart = Math.min(lengthNums - 1, Math.max(0, chatStartRaw));
            int chatEnd = (mi < chatTokens.size())
                    ? Math.min(lengthNums - 1, chatStartRaw + chatTokens.get(mi).count - 1)
                    : -1;
            if (chatEnd < chatStart) chatEnd = chatStart;

            Token ytObj = (mi < yourTokens.size()) ? yourTokens.get(mi) : null;
            Token ctObj = (mi < chatTokens.size()) ? chatTokens.get(mi) : null;

            int winStart = Math.min(yourStart, chatStart);
            int winEnd = Math.max(yourEnd, chatEnd);
            boolean plateauRelated = isPlateauRelatedMismatch(ytObj, ctObj, winStart, winEnd, chatgpt.plateaus);

            boolean unknown = (ytObj == null || ctObj == null || yourEnd < 0 || chatEnd < 0);
            boolean trueBehavioral = (!unknown && !plateauRelated && ((ytObj.type != 'S') || (ctObj.type != 'S')));

            // --------------------CHATGPT---------------------
            // Track a compact, user-friendly summary of true behavioral differences.
            if (ytObj == null || ctObj == null) {
                tbMissingTokenMismatch++;
            }
            if (trueBehavioral) {
                tbMinIndex = Math.min(tbMinIndex, winStart);
                tbMaxIndex = Math.max(tbMaxIndex, winEnd);

                if (ytObj.type == ctObj.type) {
                    if (ytObj.type == 'A' && ytObj.count != ctObj.count) {
                        tbAscMagnitude++;
                        tbDeltaA += (ctObj.count - ytObj.count);
                    } else if (ytObj.type == 'D' && ytObj.count != ctObj.count) {
                        tbDescMagnitude++;
                        tbDeltaD += (ctObj.count - ytObj.count);
                    }
                } else {
                    tbSegmentTypeMismatch++;
                    boolean yAD = (ytObj.type == 'A' || ytObj.type == 'D');
                    boolean cAD = (ctObj.type == 'A' || ctObj.type == 'D');

                    if ((yAD && ctObj.type == 'S') || (cAD && ytObj.type == 'S')) {
                        tbADvsSMismatch++;
                    }
                    if ((ytObj.type == 'A' && ctObj.type == 'D') || (ytObj.type == 'D' && ctObj.type == 'A')) {
                        tbAvsDMismatch++;
                    }
                }
            }
            // --------------------END CHATGPT-------------------

            String tag;
            if (plateauRelated) {
                tag = " (plateau-related)";
                subtotalPlateauRelated++;
            } else if (trueBehavioral) {
                tag = " (true behavioral differences)";
                subtotalTrueBehavioral++;
            } else {
                tag = " (blank/unknown)";
                subtotalUnknown++;
            }

            System.out.println("  Segment " + mi + ":" + tag);
            System.out.println("    Your:   <<<" + yourTok + ">>>    (" + yourStart + " - " + yourEnd + ")");
            System.out.println("    ChatGPT:<<<" + chatTok + ">>>    (" + chatStart + " - " + chatEnd + ")");
        }

        System.out.println("Mismatch subtotals:");
        System.out.println("  True behavioral differences: " + subtotalTrueBehavioral);
        System.out.println("  Plateau-related: " + subtotalPlateauRelated);
        System.out.println("  Blank/unknown: " + subtotalUnknown);

        // --------------------CHATGPT---------------------
        // Option A: compact summary (counts + total deltas + index coverage)
        System.out.println("True behavioral differences summary:");
        System.out.println("  Count: " + subtotalTrueBehavioral);
        System.out.println("  By type:  A-run magnitude mismatches: " + tbAscMagnitude +
                "   D-run magnitude mismatches: " + tbDescMagnitude);
        System.out.println("            Segment-type mismatches (A/D/S): " + tbSegmentTypeMismatch +
                "   Missing-token mismatches: " + tbMissingTokenMismatch);
        System.out.println("            A/D vs S mismatches: " + tbADvsSMismatch +
                "   A vs D mismatches: " + tbAvsDMismatch);

        System.out.println("  Total extra steps credited by ChatGPT vs Amit:");
        System.out.println("    A (ChatGPT  Amit) = " + (tbDeltaA >= 0 ? "+" : "") + tbDeltaA);
        System.out.println("    D (ChatGPT  Amit) = " + (tbDeltaD >= 0 ? "+" : "") + tbDeltaD);

        if (subtotalTrueBehavioral > 0 && tbMinIndex != Integer.MAX_VALUE) {
            System.out.println("  Where (index coverage):  earliest k=" + tbMinIndex + "   latest k=" + tbMaxIndex);
        }
        // --------------------END CHATGPT-------------------

        // Alignment notes: show where ChatGPT had to split an S-run because of a plateau marker '*',
        // but comparison merged it back to align with your ticker (e.g., S(3)*S(4) ~= S(7)).
        List<String> alignmentNotes = buildAlignmentNotes(yourTokens, chatTokensSplit, chatgpt.plateaus, lengthNums);
        if (!alignmentNotes.isEmpty()) {
            System.out.println("Alignment notes:");
            for (String note : alignmentNotes) System.out.println("  " + note);
        }
    }

    
    // Returns true if this mismatch segment overlaps any plateau range, and involves S tokens.
    private static boolean isPlateauRelatedMismatch(Token yt, Token ct,
                                                    int windowStart, int windowEnd,
                                                    List<PlateauInfo> plateaus) {
        if (plateaus == null || plateaus.isEmpty()) return false;

        boolean involvesS = (yt != null && yt.type == 'S') || (ct != null && ct.type == 'S');
        if (!involvesS) return false;

        int ws = Math.min(windowStart, windowEnd);
        int we = Math.max(windowStart, windowEnd);
        for (PlateauInfo p : plateaus) {
            int ps = p.startIndex;
            int pe = p.startIndex + p.size - 1;
            // overlap check
            if (we >= ps && ws <= pe) return true;
        }
        return false;
    }

    // --------------------CHATGPT---------------------
    // Builds human-friendly alignment notes explaining how ChatGPT's plateau marker '*'
    // can split an S-run (e.g., S(3)*S(4)), but the comparison layer merges it back
    // so the segment stream realigns (e.g., S(7)).
    private static List<String> buildAlignmentNotes(List<Token> yourMergedTokens,
                                                    List<Token> chatTokensSplit,
                                                    List<PlateauInfo> plateaus,
                                                    int lengthNums) {
        List<String> notes = new ArrayList<>();
        if (chatTokensSplit == null || chatTokensSplit.isEmpty()) return notes;

        // We only produce notes for S-runs that were split into 2+ tokens and overlap a plateau.
        int i = 0;
        while (i < chatTokensSplit.size()) {
            Token first = chatTokensSplit.get(i);
            int j = i;
            int sum = 0;
            while (j < chatTokensSplit.size() && chatTokensSplit.get(j).type == first.type) {
                sum += chatTokensSplit.get(j).count;
                j++;
            }

            int groupLen = j - i;
            if (first.type == 'S' && groupLen >= 2) {
                int groupStart = tokenStartIndexFromCounts(chatTokensSplit, i);
                int groupEnd = Math.min(lengthNums - 1, groupStart + sum - 1);

                if (overlapsAnyPlateau(groupStart, groupEnd, plateaus)) {
                    // Build the split form: S(3) * S(4) * S ...
                    StringBuilder splitForm = new StringBuilder();
                    for (int k = i; k < j; k++) {
                        if (k > i) splitForm.append("*");
                        splitForm.append(chatTokensSplit.get(k).display());
                    }

                    String mergedForm = new Token('S', sum).display();

                    // Find which of YOUR merged tokens covers this index window.
                    TokenWindow yourWin = findTokenWindowCoveringRange(yourMergedTokens, groupStart, groupEnd);
                    String yourPart = (yourWin == null)
                            ? "Your: [no covering token]"
                            : ("Your: " + yourWin.display + " (" + yourWin.start + "-" + yourWin.end + ")");

                    notes.add("ChatGPT " + splitForm + " treated as " + mergedForm + " for comparison (" +
                            groupStart + "-" + groupEnd + "); " + yourPart);
                }
            }

            i = j;
        }

        return notes;
    }

    private static boolean overlapsAnyPlateau(int start, int end, List<PlateauInfo> plateaus) {
        if (plateaus == null || plateaus.isEmpty()) return false;
        int s = Math.min(start, end);
        int e = Math.max(start, end);
        for (PlateauInfo p : plateaus) {
            int ps = p.startIndex;
            int pe = p.startIndex + p.size - 1;
            if (e >= ps && s <= pe) return true;
        }
        return false;
    }

    private static final class TokenWindow {
        final String display;
        final int start;
        final int end;

        TokenWindow(String display, int start, int end) {
            this.display = display;
            this.start = start;
            this.end = end;
        }
    }

    private static TokenWindow findTokenWindowCoveringRange(List<Token> tokens, int targetStart, int targetEnd) {
        if (tokens == null || tokens.isEmpty()) return null;
        int cursor = 0;
        int ts = Math.min(targetStart, targetEnd);
        int te = Math.max(targetStart, targetEnd);
        for (Token t : tokens) {
            int s = cursor;
            int e = cursor + Math.max(0, t.count) - 1;
            if (ts >= s && te <= e) {
                return new TokenWindow(t.display(), s, e);
            }
            cursor = e + 1;
        }
        return null;
    }
    // -----------------------END CHATGPT-------------------

// Computes the element start-index for a token by summing counts of prior tokens.
    private static int tokenStartIndexFromCounts(List<Token> tokens, int tokenIndex) {
        if (tokenIndex <= 0) return 0;
        int sum = 0;
        int limit = Math.min(tokenIndex, tokens.size());
        for (int i = 0; i < limit; i++) {
            int c = tokens.get(i).count;
            if (c > 0) sum += c;
        }
        return sum;
    }

    private static void addPlateauTotal(Map<String, int[]> totals, String label, int occurrences) {
        int[] v = totals.get(label);
        if (v == null) v = new int[]{0, 0};
        v[0] += 1;           // plateau count
        v[1] += occurrences; // occurrences sum
        totals.put(label, v);
    }

    
    private static char classifyStepType(float delta, float step, float eps) {
        if (approxZero(delta - step, eps)) return 'A';
        if (approxZero(delta + step, eps)) return 'D';
        return 'S';
    }

    private static String typeName(char t) {
        if (t == 'A') return "A";
        if (t == 'D') return "D";
        return "S";
    }

    private static String findPrevTurn(float[] nums, int plateauStartIdx, float step, float eps) {
        // Returns the nearest A-D or D-A turn strictly BEFORE the plateau (ignoring S-steps).
        // We scan for two consecutive non-S step types that differ.
        if (nums == null) return null;
        int n = nums.length;
        int maxJ = Math.min(plateauStartIdx - 1, n - 2);
        for (int j = maxJ; j >= 1; j--) {
            char t1 = classifyStepType(nums[j] - nums[j - 1], step, eps);
            char t2 = classifyStepType(nums[j + 1] - nums[j], step, eps);
            if ((t1 == 'A' || t1 == 'D') && (t2 == 'A' || t2 == 'D') && t1 != t2) {
                return "" + t1 + "-" + t2;
            }
        }
        return null;
    }

    private static String findNextTurn(float[] nums, int plateauEndIdx, float step, float eps) {
        // Returns the nearest A-D or D-A turn strictly AFTER the plateau (ignoring S-steps).
        if (nums == null) return null;
        int n = nums.length;
        int startJ = Math.max(1, plateauEndIdx + 1);
        for (int j = startJ; j <= n - 2; j++) {
            char t1 = classifyStepType(nums[j] - nums[j - 1], step, eps);
            char t2 = classifyStepType(nums[j + 1] - nums[j], step, eps);
            if ((t1 == 'A' || t1 == 'D') && (t2 == 'A' || t2 == 'D') && t1 != t2) {
                return "" + t1 + "-" + t2;
            }
        }
        return null;
    }

    private static String plateauPrimaryLabelFromContext(float[] nums, int startIdx, int endIdx, int n, float step, float eps) {
        if (startIdx == 0) return "At start of the chain";
        if (endIdx == n - 1) return "At end of the chain";

        char leftStepType = classifyStepType(nums[startIdx] - nums[startIdx - 1], step, eps);
        char rightStepType = classifyStepType(nums[endIdx + 1] - nums[endIdx], step, eps);

        // Peak / trough plateaus (most semantically useful)
        if (leftStepType == 'A' && rightStepType == 'D') return "In between A-D chain";
        if (leftStepType == 'D' && rightStepType == 'A') return "In between D-A chain";

        // Otherwise describe the immediate step-context explicitly
        return "Between " + typeName(leftStepType) + " and " + typeName(rightStepType);
    }

    private static List<String> plateauExtraBucketsFromContext(float[] nums, int startIdx, int endIdx, int n, float step, float eps) {
        List<String> labels = new ArrayList<>();
        if (startIdx == 0 || endIdx == n - 1) return labels;

        char leftStepType = classifyStepType(nums[startIdx] - nums[startIdx - 1], step, eps);
        char rightStepType = classifyStepType(nums[endIdx + 1] - nums[endIdx], step, eps);

        String prevTurn = findPrevTurn(nums, startIdx, step, eps);
        String nextTurn = findNextTurn(nums, endIdx, step, eps);

        // Turn-to-turn buckets (captures cases like: Between D-A and D-A, Between D-A and A-D, etc.)
        if (prevTurn != null && nextTurn != null) {
            labels.add("Between " + prevTurn + " and " + nextTurn);
        }

        // Turn-to-standalone buckets (explicitly requested)
        if (prevTurn != null && rightStepType == 'S') {
            labels.add("Between " + prevTurn + " and S");
        }
        if (nextTurn != null && leftStepType == 'S') {
            labels.add("Between S and " + nextTurn);
        }

        return labels;
    }
    private static void printChatgptBreakdown(TickerResult tickerV2) {
        System.out.println("\nCHATGPT SUMMARY RANGE: " + tickerV2.summaryRanges);
        System.out.println("CHATGPT TICKER (shape-only): \t" + tickerV2.ticker);

        System.out.println("Standalone numbers: " + tickerV2.standaloneCount +
                "   Ascending chains: " + tickerV2.ascendingChains +
                "   Descending chains: " + tickerV2.descendingChains +
                "   Plateaus: " + tickerV2.plateauCount +
                "      TOTAL: " + (tickerV2.totalSegments + tickerV2.plateauCount));
        System.out.println("Transition events: " + tickerV2.transitionEvents);

        if (tickerV2.plateaus == null || tickerV2.plateaus.isEmpty()) return;

        System.out.println("Plateau details:");
        int idx = 1;
        for (PlateauInfo p : tickerV2.plateaus) {
            System.out.println("Plateau " + idx + " (size: " + p.size + "):    Index location(k): " + p.startIndex +
                    "    Value: " + p.value + "      " + p.label);
            idx++;
        }

        System.out.println("Plateau subtotals (count / occurrences):");
        // Print the core buckets first (so they're always visible even if 0)
        String[] keyOrder = new String[]{
                "At start of the chain",
                "At end of the chain",
                "In between A-D chain",
                "In between D-A chain",
                "Between A and A",
                "Between D and D",
                "Between A and S",
                "Between S and A",
                "Between D and S",
                "Between S and D",
                "Between S and S"
        };
        for (String k : keyOrder) {
            int[] v = tickerV2.plateauTotals.get(k);
            int c = (v == null) ? 0 : v[0];
            int occ = (v == null) ? 0 : v[1];
            System.out.println(String.format("%-26s %d (occurrences: %d)", k + ":", c, occ));
        }

        // Any other labels captured
        for (Map.Entry<String, int[]> e : tickerV2.plateauTotals.entrySet()) {
            String k = e.getKey();
            boolean already = false;
            for (String fixed : keyOrder) if (fixed.equals(k)) { already = true; break; }
            if (already) continue;
            int[] v = e.getValue();
            System.out.println(String.format("%-26s %d (occurrences: %d)", k + ":", v[0], v[1]));
        }
    }

    // Deterministic ticker builder (shape-only). Counts only +/-0.1 steps as A/D chains.
    // Repeat runs (plateaus) are reported separately and marked with '*' in the ChatGPT ticker.
    static TickerResult buildTickerV2(float[] nums, int lengthNums) {
        int n = Math.min(lengthNums, (nums == null) ? 0 : nums.length);
        if (n <= 0) {
            return new TickerResult("", new ArrayList<>(), new ArrayList<>(), new ArrayList<>(), new LinkedHashMap<>(),
                    0, 0, 0, 0, 0, 0);
        }

        final float STEP = 0.1f;
        final float EPS = 0.0005f;

        // 1) Detect plateau runs and decide which repeated indices become standalone 'S' outputs
        boolean[] standaloneFromPlateau = new boolean[n];      // indices that should show up as S because of a plateau
        boolean[] standaloneCountsAsStandalone = new boolean[n]; // only true for "isolated" repeats (no adjacent chain)

        List<PlateauInfo> plateaus = new ArrayList<>();
        Map<String, int[]> plateauTotals = new LinkedHashMap<>();
        Set<Integer> plateauStarts = new HashSet<>();

        int p = 0;
        while (p < n - 1) {
            if (!approxZero(nums[p + 1] - nums[p], EPS)) { p++; continue; }

            int start = p;
            int end = p + 1;
            while (end < n - 1 && approxZero(nums[end + 1] - nums[end], EPS)) end++;

            int size = end - start + 1;
            float val = nums[start];
            plateauStarts.add(start);

            // Determine adjacency to step-chains (shape-only)
            boolean leftStep = false, rightStep = false;
            char leftDir = 0, rightDir = 0;

            if (start > 0) {
                float d = nums[start] - nums[start - 1];
                if (approxStep(d, STEP, EPS)) { leftStep = true; leftDir = 'A'; }
                else if (approxStep(d, -STEP, EPS)) { leftStep = true; leftDir = 'D'; }
            }
            if (end < n - 1) {
                float d = nums[end + 1] - nums[end];
                if (approxStep(d, STEP, EPS)) { rightStep = true; rightDir = 'A'; }
                else if (approxStep(d, -STEP, EPS)) { rightStep = true; rightDir = 'D'; }
            }

            // Allocate one occurrence to left chain endpoint if leftStep, one to right chain start if rightStep.
            // Everything else becomes standalone output due to the plateau.
            int allocLeft = leftStep ? 1 : 0;
            int allocRight = rightStep ? 1 : 0;
            int free = size - allocLeft - allocRight;
            if (free < 0) free = 0;

            // Mark indices that should be printed as S due to this plateau
            if (!leftStep && rightStep) {
                // use last occurrence as chain start
                for (int i = start; i <= end - 1; i++) standaloneFromPlateau[i] = true;
            } else if (leftStep && !rightStep) {
                // use first occurrence as chain end
                for (int i = start + 1; i <= end; i++) standaloneFromPlateau[i] = true;
            } else if (!leftStep && !rightStep) {
                // isolated repeats: all are standalone
                for (int i = start; i <= end; i++) {
                    standaloneFromPlateau[i] = true;
                    standaloneCountsAsStandalone[i] = true; // user expects these to count as standalone numbers
                }
            } else {
                // both sides: keep endpoints for chains, middle (if any) standalone
                for (int i = start + 1; i <= end - 1; i++) standaloneFromPlateau[i] = true;
            }

            // Determine plateau label using chain context AFTER segments are built
            // (we fill it in later once we know neighbour segment types).
            plateaus.add(new PlateauInfo(start, size, val, "")); // label filled later

            p = end + 1;
        }

        // 2) Build segments, and ChatGPT summaryRanges (NO plateau notation - just your usual standalone entries + ranges)
        List<SegmentInfo> segments = new ArrayList<>();
        List<String> ranges = new ArrayList<>();

        int standaloneCount = 0, ascChains = 0, descChains = 0;

        int i = 0;
        while (i < n) {
            // Standalone outputs created from plateau repeats
            if (standaloneFromPlateau[i]) {
                int j = i;
                while (j < n && standaloneFromPlateau[j]) j++;
                int count = j - i;
                segments.add(new SegmentInfo('S', count, i, j - 1, true));
                for (int k = i; k < j; k++) ranges.add(String.valueOf(nums[k]));
                for (int k = i; k < j; k++) if (standaloneCountsAsStandalone[k]) standaloneCount++;
                i = j;
                continue;
            }

            if (i == n - 1) {
                segments.add(new SegmentInfo('S', 1, i, i, false));
                ranges.add(String.valueOf(nums[i]));
                standaloneCount++;
                break;
            }

            // If next index is a plateau-standalone, we cannot start a chain through it
            if (standaloneFromPlateau[i + 1]) {
                segments.add(new SegmentInfo('S', 1, i, i, false));
                ranges.add(String.valueOf(nums[i]));
                standaloneCount++;
                i++;
                continue;
            }

            float d = nums[i + 1] - nums[i];
            boolean isAsc = approxStep(d, STEP, EPS);
            boolean isDesc = approxStep(d, -STEP, EPS);

            if (!isAsc && !isDesc) {
                segments.add(new SegmentInfo('S', 1, i, i, false));
                ranges.add(String.valueOf(nums[i]));
                standaloneCount++;
                i++;
                continue;
            }

            int j = i + 1;
            float dir = isAsc ? STEP : -STEP;
            while (j < n - 1) {
                if (standaloneFromPlateau[j + 1]) break;
                float dd = nums[j + 1] - nums[j];
                if (!approxStep(dd, dir, EPS)) break;
                j++;
            }

            int len = j - i + 1;
            if (isAsc) {
                segments.add(new SegmentInfo('A', len, i, j, false));
                ascChains++;
            } else {
                segments.add(new SegmentInfo('D', len, i, j, false));
                descChains++;
            }
            ranges.add(nums[i] + "->" + nums[j]);

            // Overlap on immediate reversal (same behaviour as your prior buildTickerV2)
            if (j < n - 1) {
                float after = nums[j + 1] - nums[j];
                boolean nextAsc = approxStep(after, STEP, EPS);
                boolean nextDesc = approxStep(after, -STEP, EPS);
                if ((isAsc && nextDesc) || (isDesc && nextAsc)) i = j; else i = j + 1;
            } else {
                i = n;
            }
        }

        
        // 3) Compute plateau labels and subtotal buckets.
        // Primary label = immediate context (what the series is doing right before / right after the plateau).
        // Subtotals are based on the immediate step-context right before / right after the plateau (using your A/D step-size rules).
        // This keeps subtotals mutually exclusive and avoids counting a single plateau in multiple "turn-context" buckets.
        for (int pi = 0; pi < plateaus.size(); pi++) {
            PlateauInfo pInfo = plateaus.get(pi);
            int startIdx = pInfo.startIndex;
            int endIdx = startIdx + pInfo.size - 1;

            String primary = plateauPrimaryLabelFromContext(nums, startIdx, endIdx, n, STEP, EPS);
            PlateauInfo filled = new PlateauInfo(startIdx, pInfo.size, pInfo.value, primary);
            plateaus.set(pi, filled);

            addPlateauTotal(plateauTotals, primary, pInfo.size);
            }

        int plateauCount = plateaus.size();

        // 4) Build ticker string from segments, inserting '*' at plateau starts, and '-' for overlap transitions
        StringBuilder ticker = new StringBuilder();
        int transitionEvents = 0;

        // Determine where to insert '*' relative to segments (before a segment, or after a segment)
        Set<Integer> starBeforeSeg = new HashSet<>();
        Set<Integer> starAfterSeg = new HashSet<>();
        for (int ps : plateauStarts) {
            int containing = -1;
            for (int si = 0; si < segments.size(); si++) {
                SegmentInfo seg = segments.get(si);
                if (seg.startIndex <= ps && ps <= seg.endIndex) { containing = si; break; }
            }
            if (containing == -1) continue;
            SegmentInfo seg = segments.get(containing);
            if (seg.startIndex == ps) starBeforeSeg.add(containing);
            else starAfterSeg.add(containing);
        }

        for (int si = 0; si < segments.size(); si++) {
            SegmentInfo seg = segments.get(si);

            // '*' marker at plateau commencement
            if (starBeforeSeg.contains(si)) ticker.append("*");

            // '-' transition marker (only between chain segments that overlap by one element)
            if (si > 0) {
                SegmentInfo prev = segments.get(si - 1);
                if ((prev.type == 'A' || prev.type == 'D') && (seg.type == 'A' || seg.type == 'D')
                        && prev.endIndex == seg.startIndex) {
                    ticker.append("-");
                    transitionEvents++;
                }
            }

            if (seg.type == 'S') {
                // Compress consecutive standalones into S(n) to keep ticker length manageable.
                int run = Math.max(1, seg.count);
                int sj = si + 1;

                // Don't merge across a plateau marker boundary (starBeforeSeg inserts '*' before that segment),
                // and don't merge across a starAfter boundary (which inserts '*' after the previous segment).
                while (sj < segments.size()) {
                    if (starBeforeSeg.contains(sj)) break;
                    if (starAfterSeg.contains(sj - 1)) break;

                    SegmentInfo nxt = segments.get(sj);
                    if (nxt.type != 'S') break;

                    run += Math.max(1, nxt.count);
                    sj++;
                }

                if (run == 1) ticker.append('S');
                else ticker.append('S').append("(").append(run).append(")");

                // We consumed segments up to sj-1
                si = sj - 1;
            } else {
                ticker.append(seg.type).append("(").append(seg.count).append(")");
            }

            if (starAfterSeg.contains(si)) ticker.append("*");
        }

        int totalSegments = standaloneCount + ascChains + descChains;

        return new TickerResult(
                ticker.toString(),
                ranges,
                segments,
                plateaus,
                plateauTotals,
                standaloneCount,
                ascChains,
                descChains,
                plateauCount,
                totalSegments,
                transitionEvents
        );
    }
    // -----------------------END CHATGPT-------------------

}