suga

#!/usr/bin/bash python

import csv
import datetime
from datetime import datetime
from colorama import Back, Fore, Style
import sys
from termcolor import colored, cprint
from colorama import init
import numbers
import time
import itertools
from itertools import zip_longest
from time import sleep
import hashlib
import statistics
import shutil
import os
from sty import fg, bg, ef, rs, RgbFg
import glob
import random
import numpy as np
shutil.copy('/Users/King/data.csv', '/Users/King/SpyFlow Dropbox/SpyFlow_Dropbox/data.csv')


with open('/Users/King/Spy_data_analysis.csv', 'w+') as csv_file2:
    writer_labels = ['ref_Num', 'Date', 'Time',  'Price', 'MoneyPrice', 'xString', 'qrdivmax', 'EstimatedPrice', 'EstPrice2', 'MTR', 'PainGauge', 'DR', 'IntradayStrength', 'new_Strength', 'LFP', 'LFPC','mRatio','sneakR','qratio','sneakRSum','avgsneakR','avgQR','MIVCount','avg_Liq_change','lastDPrice','Weighted_Avg_DPrice','Weighted_Movement','UDV','UDR_Ticks','MACD','sneakR_Sum','avg_sneakR','gapRatio','Resistance','Support', 'ChgOpen', 'OpenPrice', 'HighPrice', 'LowPrice', 'LiqChange', 'Liquidity', 'Volume', 'MoneyFlow', 'MIV_Index', 'AvgVol', 'MTR_copy', 'PTLT Ratio', 'gapRatio', 'GDR', 'PVS', 'Vol sneakR Ratio', 'UDR', 'SketchDist', 'MIV_Value', 'VIX_Estimate']
    wr = csv.writer(csv_file2)
    wr.writerow(writer_labels)


with open('/Users/King/liveplot_analysis.csv', 'w') as plotfile:
    writer_labels = ['ref_Num', 'Date', 'Time',  'Price', 'sneakR', 'qratio', 'LFPC', 'PVS', 'MIV_Index', 'Liquidity', 'LFP', 'Liq_change']
    wr = csv.writer(plotfile)
    wr.writerow(writer_labels)

with open('/Users/King/Spy_var_analysis.csv', 'w+') as plotfile:
    vardatalabels = ['Date', 'Time', 'ref_Num', 'Price', 'ChgO', 'PG', 'MTR', 'DR', 'GR', 'GDR', 'PVS', 'avgVol', 'ITDS', 'NS', 'SS', 'avgQR', 'ALQ', 'UDR', 'VSR', 'QRS_Index', 'avgVSR', 'DRC', 'CashOpen', 'Liquidity', 'MTRStrength', 'UDRStrength', 'avgLFP', '45Min', '60Min', '120Min']
    wr = csv.writer(plotfile)
    wr.writerow(vardatalabels)

adj_Strength = float()
analysis_list = []
analysis_log = []
avg_OC_Range = float()
Avg_DPrice = float()
Avg_Down_Move = float()
avg_Flow = float(1)
avg_HL_Range = float()
avgHigh = float()
avgLow = float()
avg_Liq_change = float()
Avg_MIV_Spike = float()
avg_sneakR = float()
Avg_Up_Move = float()
avgVol = float()
Avg_Move = float()
avgQR = float()
avgVIX = float()
avg_large_LFPC = float()
avg_mRatio = float()
avg_up_move_clone = float()
avg_down_move_clone = float()


BB_Strength = float()
bearTS1 = bool
FMC = bool
bearTS = bool
BES = bool
bullTS = bool

CashOpenHash = '00491302948265c47e651fcff99fd9fb'
CashOpen = float()
CoverCount = int()
CoverMoney = float()
CoverPrice = float()
C_Price = float()
CoverLiquidity = float()
CoverVolumeTotal = float()
Cumulutive_DPrice = float()
countitems = int()


day_left = float()
DU = int()
DD = int()
DownTicks = int()
down_val = float()
down_val_count = int()
DOWN_c = int()
DOWN_IV = float()
DP_list = []
DP_Uptick = int()
DP_Downtick = int()
DP_UptickList = []
DP_DowntickList = []
DRC = int()
DR = float()
Distribution_Price = float()


est_price_x = float()
est_diff_x = float()
est_diff1 = float()
est_price1 = float()
est_price = float(1)
LQPPrice_match = float()
LQPPrice_no_match = float()
EstLiqPrice = float()
EstimatedPrice = float()
est_price_filled = bool
ExtremelyLargeFlowCount = int()
ExtremelyLargesneakRCount = int()
extremeBearTS = bool
extremeBullTS1 = bool
extremeBullTS = False
extremeDR = bool
extremeGR = bool

gapRatio = float()
gapDistanceRatio = float()

highlist = []
HOD = float()

info_datalist = []

labels = str()
LargeFlowCount = int()
LargeFlowSum = float()
LargesneakRCount = int()
lastFPrice = float()
Liq_Tick_Total = int()
LFPC = float()
LFP = float(1)
LOD = float()
log = []
LongPrice = float()
LFPC_Count = int()
lowlist = []
LQP_Match = bool

Mark_The_Maker = bool
MIV_Spike_List = []
MIV_Spike_Count = int()
MIV_Spike = float()
MUTick = int()
MDTick = int()
MTR = float()
MTR_copy = float()
MT = int()
mRatio = float()
MIV_Index = float()
money_analysis_log = []
M_Price_clone = float()
MoneyTickGauge = float()
MLOD = bool
MHOD = bool
MHOD_Price = float()
MLOD_Price = float()
MTR_Strength = float()
MTR_s = int()

new_sneakR = float()
new_Strength_String = str()
nTS = bool
# newvix = float()

pause = float()
PD = bool
PVP = float()
PainGauge = float()
PG = float()
PainGaugePct = float()
PTLT_Ratio = float()
Price_Tick_Total = int()
price_tick_str = str()
PriceTickGauge = float()
PriceUpTickGauge = float()
PriceDownTickGauge = float()
projected_ss_eod = float()
pg_up_var = float()
pg_down_var = float()

real_ticks = int()
rawdatalist = []
rawdatalist1 = []
rawdatalist2 = []
rawdatalist3 = []
rPVS = float()

SAMS = bool
BAMS = bool
countbam = int()
ShortPrice = float()
ShortVolumeTotal = float()
S_Price = float()
ShortLiquidity = float()
ShortCount = int()
ShortMoney = float()
sumVol = float()
sum_Flow = float()
sumFlow = float()
SumLiq = float()
sum_down_move = float()
sum_down_count = int()
sum_up_move = float()
sum_up_count = int()
sum_OC_Range = float()
sum_HL_Range = float()
sneakR = float()
sneakR_analysis_log = []
sneakR_Sum = float()
sneakR_lgst_avg_ratio = float()
sneakR_log = []
Status = str()
sum_QR = float()
sum_large_LFPC = float()
sum_MRatio = float()
sum_LFPC = float()
sumLFP = float()


TA = bool
TB = bool
TATBR_Sum = float()
TATBR_Ratio = float()
TATBR_A = float()
TATBR_B = float()
TickGauge = float()
TradingAbove_Count = int()
TradingAbove_Diff = float()
TradingBelow_Count = int()
TradingBelow_Diff = float()
technicals = []
technicals_list = []
TotalDiff = float()
trend = float()
PivotSpread = float()

UDR = float()
UD_Ratio = float()
UDR_Ticks = int()
UDV = int()
unfilled_TA_price = float()
unfilled_TA_price = float()
UP_c = int()
UP_IV = float()
up_val = float()
up_val_count = int()
underline = str()
UpTicks = int()
UDR_Strength = float()
UDR_s = int()
sro_ref = int()

VeryLargesneakRCount = int()
VeryLargeFlowCount = int()
VSR = float()
VIX = float()
VIX_List = []
sumVSR = float()
avgVSR = float()
avgLFP = float()

QR = float()
qratio = float()
qratio_div_max = float()

writedatalist = []
Weighted_Avg_DPrice = float()
Weighted_Movement = float()

xratio = float()
xString = ''




datafile = '/Users/King/data.csv'
historicaldir = '/Users/King/SPY_CSV_FULL/FULLFILES/'
Liquidity_Data = str()



Resistance = float()
Support = float()
SketchDist = float()
hidden_strength = float()
hs_up = int()
hs_down = int()
mpricelist = []
prevpricelist15 = []
prevpricelist45 = []
prevpricelist60 = []
prevpricelist120 = []
chg_15 = float()
chg_45 = float()
chg_60 = float()
chg_120 = float()
MIV_Value = float()
runningValueIndex = float()
avgMPrice = float()
QRS_Index = float()
menu_ans = input('What would you like to do? \n [1] Print Liquidity   |   [2] ComparisonChart    |     [3] Tcopy Ranges    |     [4] Show Est TA/TB Prices     |     [5] Analyze Scenarios     |      [6] Data Analysis\n')
if menu_ans == '1':
    Liquidity_Data = input('Would you like to print liquidity data? [y/n]: ')
    PrintInfo = True
if menu_ans == '2':
    import graphcomp
if menu_ans == '3':
    option3 = True
if menu_ans == 'oldfile':
    PrintInfo = True
    try_file = input('Enter Date [MM_DD_YYYY]:  ')
    Liquidity_Data = input('Would you like to print liquidity data? [y/n]: ')


    # for file in glob.glob (historicaldir+'*csv'):
        # historicaldate = file[39:-8]

    datafile = historicaldir+'SPY_'+try_file+'FULL.csv'


with open(datafile, 'r') as csv_file:
    csv_reader = csv.reader(csv_file)
    header = next(csv_reader)


    ref = []                                 # Start off w/ empty list
    ref_Num = int(0)                        # First to go in list = ref # (390 cells in 1 day)(using ref+=1 for each row)
    data = []                                # Not sure but I could rearrange for liquidity?
    Liquidity = float()
    found = int(0)
    Range = []
    Target = []
    filled = bool
    filled_Price = float()
    Range_List = {}
    Low_Range_Found = {}
    High_Range_Found = {}
    ht_filled = bool
    hr_filled = bool
    lr_filled = bool
    lt_filled = bool
    lastDPrice = float()

    lows_found = int()
    highs_found = int()
    Tick = int()
    Range_Found = {}
    range_ref_String = ('')
    dTime = []
    PrintInfo = bool
    new_range = bool
    t = bool
    tLow = bool
    tHigh = bool
    Target = float()
    Range_Dict = {}
    TickString = str()
    Tick_String = ''
    Strength = int()
    StartTraceback = {}
    day_Count = int()
    tList = []
    Last = float()
    LT = float()
    HT = float()
    ATR = float()
    OC_ATR = float()
    Avg_ATR = float()
    TrendStrength = ''
    Previous = []
    allfoundallfilled = {}
    lowfilled = float()
    highfilled = float()
    rangefilled = bool
    low_Ranges_Filled = int()
    high_Ranges_Filled = int()
    high_Targets_Filled = int()
    low_Targets_Filled = int()
    prevVol = float(1)
    prevFlow = float(1)
    lastFlow = float(1)
    lastVol = float(1)
    prevIndexValue = float(1)
    prevPrice = float(1)
    lastLFPC = float(1)
    lastsneakR = float(1)
    lastmRatio = float(1)

    Status = str('')
    RangeTarget = float()
    rFound = bool
    count = int(0)
    PCT_Range_Str = ''



    sum_OHLC_Range = float()
    WarningString = ''
    sum_Liq = float()
    avg_Liq_change = float()
    HighRangeFlow = float()
    LowRangeFlow = float()
    LiqFlowPrice = float()
    LiqFlowPriceClone = float()
    EntryStr = str()
    OC_HL_RangePct = float()
    StrengthReference = float()
    AvgStrengthReference = float()
    counter = int()

    liqList = []
    PULQ = bool

    BuyVolume = float()
    BuyPower = float()
    ShortVolume = float()
    ShortPower = float()
    SellVolume = float()
    SellPower = float()
    BuySellRatio = float()
    HL_RangePct = float()

    Price1 = float()
    prevPrice1 = float()
    gapDown = int()
    gapUp = int()
    gapUpDistance = float()
    gapDownDistance = float()
    prevMPrice = float()
    prevMPrice2 = float()
    prevPrice1 = float()
    lastMPrice = float()
    lastHPrice = float()
    lastLPrice = float()






    for row in csv_reader:
        range_ref_String = ''
        LRS = '$'
        LRT = '$'
        HRS = '$'
        HRT = '$'
        found_Price_String = '$'
        end_String = 'Price while found: $'
        # row = [Time, Open, Close, High, Low, realVol, Money_Flow]
        ref_Num += 1
        dTime = str(datetime.strptime(row[0], '%a %b %d %H:%M'))
        Time = dTime[-14:]
        Open_Price = float(row[1])                  # Price Data Dictionary
        Close_Price = float(row[2])                 # Price Data Dictionary
        High_Price = float(row[3])                  # Price Data Dictionary
        Low_Price = float(row[4])                   # Price Data Dictionary
        Money_Flow = float(row[6])                  # Price Data Dictionary
        Vol = row[5]  # Price Data Dictionary
        f_Vol = float(Vol[:-1])  # Price Data Dictionary
        m_Vol = str(Vol[-1:])  # Price Data Dictionary
        if m_Vol == "K":  # Price Data Dictionary
            f_Vol = f_Vol * 1000  # Price Data Dictionary
        if m_Vol == "M":  # Price Data Dictionary
            f_Vol = f_Vol * 1000000
        if m_Vol != "K" and m_Vol != "M":
            f_Vol = float(row[5])  # Price Data Dictionary
        if f_Vol < 1:
            M_Price = HLCC
        else:
            M_Price = round(float(Money_Flow) / f_Vol, 2)
        HLCC = float(High_Price + Low_Price + Close_Price + Close_Price)/4         # Price Data Dictionary & RangeReference Dictionary                          # Price Data Dictionary & RangeReference Dictionary
        Diff = round(HLCC - M_Price, 2)
        findDiff = round(M_Price - Close_Price, 2)
        TotalDiff += findDiff
        PivotPrice = round(Close_Price + TotalDiff, 2)
        PivotSpread += findDiff
        PVP = round(100*(PivotSpread / Close_Price), 3)
        if PivotPrice > Close_Price + .45:
            PivotStr = Fore.CYAN+str(PivotPrice)+Style.RESET_ALL
        if PivotPrice < Close_Price - .45:
            PivotStr = Fore.RED+str(PivotPrice)+Style.RESET_ALL

        if abs(PivotPrice - Close_Price) < .15:
            PivotStr = Fore.WHITE+str(PivotPrice)+Style.RESET_ALL

        if abs(PivotPrice - Close_Price) > .15 and abs(PivotPrice - Close_Price) < .45:
            PivotStr = Fore.YELLOW+str(PivotPrice)+Style.RESET_ALL                                                # Price Data Dictionary & RangeReference Dictionary & Data Dictionary

        if PivotPrice > Close_Price + .75:
            PivotStr = Fore.CYAN+Style.BRIGHT+str(PivotPrice)+Style.RESET_ALL

        if PivotPrice < Close_Price - .75:
            PivotStr = Fore.RED+Style.BRIGHT+str(PivotPrice)+Style.RESET_ALL
        MMM = float(f_Vol * HLCC)                                                     # Price Data Dictionary & RangeReference Dictionary & Data Dictionary
        Liq_change = float(Money_Flow - MMM)                                            # Price Data Dictionary & RangeReference Dictionary & Data Dictionary
        Liquidity += Liq_change                                                         # Price Data Dictionary & RangeReference Dictionary & Data Dictionary
        Date = str(Time[:5])                                                            # Important
        military_time = str(Time[-8:])
        criteria = abs(.003*HLCC)
        hashTime = hashlib.md5(str.encode(military_time))
        Liq_Tick = int()
        Price_Tick = int()
        tREF = int()
        liqstr = '{:20,.2f}'.format(Liquidity)
        liqchgstr = '{:20,.2f}'.format(Liq_change)
        mf_Str = '{:20,.2f}'.format(Money_Flow)

        rFound = False

        OC_Range = abs(Close_Price - Open_Price)
        HL_Range = abs(High_Price - Low_Price)
        sum_OC_Range += OC_Range
        sum_HL_Range += HL_Range
        avg_HL_Range = round(sum_HL_Range / ref_Num, 2)
        avg_OC_Range = round(sum_OC_Range / ref_Num, 2)

        sum_Liq += abs(Liq_change)
        liqList.append(sum_Liq)

        abs_Liq = abs(Liq_change)
        prevLiq = float()

        mticksymbol = ''
        ticksymbolc = ''
        ticksymbolo = ''
        M_Price_clone = M_Price
        mpricelist.append(M_Price)
        avgMPrice = statistics.mean(mpricelist)
        highlist.append(High_Price)
        lowlist.append(Low_Price)


        Weighted_Movement += (High_Price - Open_Price) + (Low_Price - Close_Price) + (Close_Price - Open_Price)
        Weighted_Movement = round(Weighted_Movement, 2)
        prevpricelist15.append(Close_Price)
        prevpricelist45.append(Close_Price)
        prevpricelist60.append(Close_Price)
        prevpricelist120.append(Close_Price)


        if hashTime.hexdigest() == CashOpenHash:
            CashOpen = Open_Price
            HOD = High_Price
            LOD = Low_Price

        if ref_Num >= 1:
            CashOpen = CashOpen
            if ref_Num >= 16:
                if ref_Num < 374:

                    chg_15 = round(100*(Close_Price - prevpricelist15[0]) / prevpricelist15[0], 2)
                    prevpricelist15.append(Close_Price)
                    prevpricelist15.pop(0)

                else:
                    chg_15 = round(100*(Close_Price - prevpricelist15[0]) / prevpricelist15[0], 2)
                    prevpricelist15.append(Close_Price)

            if ref_Num >= 46:
                chg_45 = round(100*(Close_Price - prevpricelist45[0]) / prevpricelist45[0], 2)
                prevpricelist45.append(Close_Price)

                if ref_Num < 344:
                    prevpricelist45.pop(0)


            if ref_Num >= 61:
                chg_60 = round(100*(Close_Price - prevpricelist60[0]) / prevpricelist60[0], 2)
                prevpricelist60.append(Close_Price)

                if ref_Num < 329:
                    prevpricelist60.pop(0)


            if ref_Num >= 121:
                chg_120 = round(100*(Close_Price - prevpricelist120[0]) / prevpricelist120[0], 2)
                prevpricelist120.append(Close_Price)

                if ref_Num < 269:
                    prevpricelist120.pop(0)



        chg_Open = round(100*(Close_Price - CashOpen) / CashOpen, 2)

        if Close_Price > Open_Price:
            sum_up_move += abs(Close_Price - Open_Price)
            sum_up_count += 1
        if Close_Price < Open_Price:
            sum_down_move += abs(Close_Price - Open_Price)
            sum_down_count += 1


        if sum_up_count >= 1:
            avg_up_move_clone = round(sum_up_move / sum_up_count, 2)
        if sum_down_count >= 1:
            avg_down_move_clone = round(sum_down_move / sum_down_count, 2)




        if Money_Flow > 0:
            MIV_Index = round(100 * (f_Vol / prevVol) - 100 * ((Money_Flow * HLCC) / (prevFlow * prevPrice)), 3)
            runningValueIndex += MIV_Index
            prevPrice = Close_Price
            prevFlow = Money_Flow
            prevVol = f_Vol
            prevIndexValue = MIV_Index
            MIV_Index_String = str(MIV_Index)
            runningValueIndex_String = str(runningValueIndex)
            MIV_Index_String = str(round(MIV_Index, 2))
            if ref_Num >= 2:
                MIV_Value = round(MIV_Index + runningValueIndex / 2, 3)


        if ref_Num >= 10:
            highlist.pop(0)
            lowlist.pop(0)

        avgHigh = statistics.mean(highlist)
        avgLow = statistics.mean(lowlist)



        if ref_Num > 3 and High_Price > HOD:
            HOD = High_Price
        else:
            HOD = HOD

        if ref_Num > 3 and Low_Price < LOD:
            LOD = Low_Price
        else:
            LOD = LOD


        if ref_Num >= 2:
            prevPrice1 = Close_Price
            prevMPrice = M_Price


        if ref_Num % 2 != 0:
            Price1 = Close_Price
            prevMPrice1 = M_Price
            prevVol1 = f_Vol
            prevFlow1 = Money_Flow
            HPrice1 = High_Price
            LPrice1 = Low_Price

        if ref_Num % 2 == 0:
            Price2 = Close_Price
            prevMPrice2 = M_Price
            prevVol2 = f_Vol
            prevFlow2 = Money_Flow
            HPrice2 = High_Price
            LPrice2 = Low_Price


        if ref_Num % 2 != 0 and ref_Num > 2:
            Last = Price2
            lastMPrice = prevMPrice2
            lastVol = prevVol2
            lastFlow = prevFlow2
            lastHPrice = HPrice2
            lastLPrice = LPrice2


        if ref_Num % 2 == 0 and ref_Num >= 2:
            Last = Price1
            lastMPrice = prevMPrice1
            lastVol = prevVol1
            lastFlow = prevFlow1
            lastHPrice = HPrice1
            lastLPrice = LPrice1




        sumFlow += Money_Flow
        SumLiq += abs(Liq_change)
        sumVol += f_Vol
        sum_MRatio += mRatio
        sumVSR += VSR
        avgVSR = round(sumVSR / ref_Num, 2)
        sneakR_log.append(sneakR)
        if Money_Flow > 0 and OC_Range + HL_Range > 0:
            sneakR = round(.0000001*(Money_Flow / (OC_Range + HL_Range)), 2)
            new_sneakR = round(.0000001*(Money_Flow /  (HL_Range)), 2)
            sneakR_Sum += round(sneakR, 2)
            avg_sneakR = round(sneakR_Sum / ref_Num, 2)
            day_left = 390 - ref_Num
            VSR = round(sumVol / sneakR_Sum, 2)

            VIX = round((avgVSR / VSR) * (avgVSR / 1000), 2)

            VIX_List.append(VIX)
            if ref_Num >= 30:
                VIX_List.pop(0)
                avgVIX = np.mean(VIX_List)
                VIX = round((VIX + avgVIX), 2)


            projected_ss_eod = round(day_left * avg_sneakR + sneakR_Sum + 200, 2)



        if ref_Num >= 2:
            avgVol = round(sumVol / ref_Num, 2)
            avg_Flow = round(sumFlow / ref_Num, 2)
            avg_Liq_change = round(SumLiq / ref_Num, 2)
            xratio = round(100 * abs(Liq_change) / abs(Liquidity), 3)
            lastLFPC = LFPC
            lastmRatio = mRatio
            lastsneakR = sneakR
            avg_sneakR = round(sneakR_Sum / ref_Num, 2)
            avg_mRatio = round(sum_MRatio / ref_Num, 2)
            avgQR = round(sum_QR / ref_Num, 2)
            if abs(Money_Flow) > 0 and abs(Liq_change) > 0:
                mRatio = round(Money_Flow / avg_Flow, 3)
                QR = round(sneakR / mRatio, 2)
                sum_QR += QR

        if ref_Num >= 2 and mRatio > 0:
            qratio_div_max = round(qratio / 468, 2)

        if mRatio > 0:
            qratio = round(sneakR / mRatio, 2)

        QRS_Index = round(sum_QR - sneakR_Sum, 2)


        analysis_list = [Date, military_time, Close_Price, M_Price, liqchgstr, liqstr, mf_Str, mRatio, sneakR]

        if mRatio >= 1:
            LargeFlowCount += 1
            LargeFlowSum += mRatio
            analysis_log.append(analysis_list)
            if mRatio >= 2:
                VeryLargeFlowCount += 1
                if mRatio >= 5:
                    ExtremelyLargeFlowCount += 1
            money_analysis_log.append(Money_Flow)

        if sneakR >= 100:
            if analysis_list not in analysis_log:
                analysis_log.append(analysis_list)
            sneakR_analysis_log.append(sneakR)
            LargesneakRCount += 1
            if sneakR >= 200:
                VeryLargesneakRCount += 1
                if sneakR >= 300:
                    ExtremelyLargesneakRCount += 1


        if UP_c >= 1 and DOWN_c >= 1:
            UDR = round((UP_c / DOWN_c) -.1, 3)
            UDV = UP_c - DOWN_c

            if UpTicks >= 1 and DownTicks >= 1:
                UDR_Ticks = round(UpTicks - DownTicks, 3)

        MACD = UDR_Ticks - UDV

        if UDV > UDR_Ticks:
            price_tick_str = fg(191)+bg(52)+'Last Price: [$%s' % Close_Price+']'

        if UDV <= UDR_Ticks:
            price_tick_str = fg(123)+bg(0)+'Last Price: [$%s' % Close_Price+']'





        if abs(Liq_change) > 0:
            LFP = round(Money_Flow / abs(Liq_change) *.01, 3)
            LFPC = round(1000 * (abs(Liq_change) / Money_Flow) * .01, 4)
            sum_LFPC += LFPC
            if LFPC >= .001:
                LFPC_Count += 1
            if Liq_change > 0:
                sum_large_LFPC += LFPC

            sumLFP += LFP


            if Liq_change < 0:
                sum_large_LFPC += (LFPC * -1)

        if LFPC_Count >= 1:

            avg_large_LFPC = round(100*(sum_large_LFPC / LFPC_Count), 2)

        avg_LFPC = round(100*(sum_LFPC / ref_Num), 2)
        avgLFP = round(sumLFP / ref_Num, 3)
        if Close_Price < Last:
            down_val += abs(Close_Price - Last)
            down_val_count += 1

        if Close_Price > Last:
            up_val += Close_Price - Last
            up_val_count += 1
        if up_val_count >= 1 and down_val_count >= 1:
            trend = round(up_val_count / down_val_count, 2)


        timecounter = .02
        if ref_Num >= 15:
            timecounter = .02-((ref_Num / 15) * .000669)
            pause = timecounter/.05







        if Close_Price >= Open_Price:
            PriceTickGauge += round(Close_Price - Open_Price, 3)
            MoneyTickGauge += round(M_Price - lastMPrice, 3)

        if Close_Price <= Open_Price:
            PriceTickGauge += round(Close_Price - Open_Price, 3)
            MoneyTickGauge += round(M_Price - lastMPrice, 3)

        if ref_Num >= 1:
            TickGauge = round(PriceTickGauge / MoneyTickGauge, 4)

        if M_Price > High_Price or M_Price < Low_Price:
            if M_Price > High_Price:
                xString = 'TA'
            else:
                xString = 'TB'

        else:
            xString = ''



###############################################################################################

        if abs(Liq_change) > 0 and Money_Flow > 0:
            if LFPC >= .0012:
                rawdatalist = [Date, military_time, Close_Price, liqchgstr, liqstr, mf_Str, M_Price, LFP, LFPC, est_price_x, mRatio, sneakR, qratio]

                LFP = round(Money_Flow / abs(Liq_change) *.01, 3)
                est_diff_x = round(LFPC * Close_Price, 2)
                if qratio >= 80:
                    est_diff_x = abs(est_diff_x) * -1
                if Liquidity < 0:
                    if Liq_change < 0:
                        est_price_x = round(est_diff_x + Close_Price, 2)
                        TA = True
                        TB = False
                    if Liq_change > 0:
                        est_price_x = round(Close_Price + (-1 * est_diff_x), 2)
                        TA = False
                        TB = True


                if Liquidity > 0:
                    if Liq_change < 0:
                        est_price_x = round(Close_Price + (-1 * est_diff_x), 2)
                        TA = False
                        TB = True
                    if Liq_change > 0:
                        est_price_x = round(est_diff_x + Close_Price, 2)
                        TA = True
                        TB = False

                if TA == True:
                    if Close_Price >= est_price_x:
                        Status = 'FILLED'
                    if Close_Price < est_price_x:
                        if HOD >= est_price_x:
                            Status = 'DUD'
                        if HOD < est_price_x:
                            Status = '[ NYF ]'
                            unfilled_TA_price = est_price_x

                if TB == True:
                    if Close_Price <= est_price_x:
                        Status = 'FILLED'
                    if Close_Price > est_price_x:
                        if LOD <= est_price_x:
                            Status = 'DUD'
                        if LOD > est_price_x:
                            Status = '| NYF |'
                            unfilled_TB_price = est_price_x


                # if LFPC >= .002:
                #     if Liq_change < 0:
                #         est_price_x = round(est_diff_x + Close_Price, 2)
                #     if Liq_change > 0:
                #         est_price_x = round(Close_Price + (-1 * est_diff_x), 2)
                    #
                    # if LFPC >= .01:
                    #     if Liq_change < 0:
                    #         est_price_x = round(Close_Price + (-1 * est_diff_x), 2)
                    #     if Liq_change > 0:
                    #         est_price_x = round(est_diff_x + Close_Price, 2)
                    #



















######### Changing status in opt 4 to show filled/unfilled est TA/TB prices
#########################################################################

        with open('/Users/King/liveplot_analysis.csv', 'a') as plotfile:
            variables = [ref_Num, Date, military_time, Close_Price, sneakR, qratio, LFPC, PivotSpread, MIV_Index, Liquidity, PainGauge, LFP, Liq_change]
            filereader = csv.reader(plotfile)
            wr = csv.writer(plotfile)
            wr.writerow(variables)







        percent_Strength = Strength / ref_Num
        allData = [ref_Num,Date, military_time, High_Price,Low_Price,Close_Price, HLCC, M_Price, f_Vol, Money_Flow,MMM, Liquidity,Liq_change]
        Data_Dict = {'REF#':[ref_Num],'Date':[Date],'Time':[military_time], 'Close_Price':[Close_Price], 'M_Price':[M_Price], 'Volume':[f_Vol]}
        '''USING THIS DATA
                [0]REFERENCE NUMBER
                [1]DATE
                [2]MILITARY_TIME
                [3]HIGH_PRICE
                [4]LOW_PRICE
                [5]CLOSE_PRICE
                [6]HLCC
                [7]M_Price
                [8]F_VOL
                [9]MONEY_FLOW
                [10]MARKETMAKERMOVE 'MMM'
                [11]LIQUIDITY
                [12]LIQ_CHANGE
                '''





        if abs(allData[7]-allData[6]) >= criteria:
            diff = abs(M_Price - Close_Price)
            Range_Clause = True
            range_identifier_all = 'All'
        else:
            Range_Clause = False
            rFound = False
            rPVS += round(M_Price - Close_Price, 2)

        if Range_Clause == True:
            rFound = True
            MLOD = False
            MHOD = False
            r_price = M_Price
            found_Price = HLCC
            Low_Range = round(HLCC - abs(float(M_Price - HLCC)), 2)
            High_Range = round(HLCC + abs(float(M_Price - HLCC)), 2)
            Low_Target = round(Low_Range - abs(float(M_Price - HLCC)), 2)
            High_Target = round(High_Range + abs(float(M_Price - HLCC)), 2)
            RT_Reference1 = [Low_Range, High_Range, Low_Target, High_Target]
            LRS = '$' + str(Low_Range)
            LRT = '$' + str(Low_Target)
            HRS = '$' + str(High_Range)
            HRT = '$' + str(High_Target)
            found_Price_String = '$' + str(found_Price)
            RT_Reference = [LRS, LRT, HRS, HRT]
            lows = [LRS, LRT]
            highs = [HRS, HRT]
            range_ref_String = range_ref_String
            target_String = range_ref_String + ': $'
            end_String = 'Price while found: $' + str(Close_Price)
            Target_String = '$' + str(Target)



            if abs(Liq_change) > 0:
                LiqFlowPrice = .01*round(Money_Flow / abs(Liq_change), 3)
                VolLiqPrice = round(f_Vol / abs(Liq_change), 2)
                LiqFlowPriceClone = round(1000 * (abs(Liq_change) / Money_Flow), 4) * .01


            if M_Price >= High_Range:
                found += 1
                range_ref_String = "HIGH TARGET"
                tHigh = True
                RangeTarget = High_Target
                Target = M_Price
                range_identifier = 'High'
                found_Price = HLCC
                range_identifier_all = 'All'
                thList = ['HIGH TARGET', High_Target, highfilled]
                filled = False
                tLow = False
                ht_filled = False
                hr_filled = False
                highs_found += 1
                HighRangeFlow += Money_Flow
            elif M_Price<= Low_Range:
                found += 1
                range_ref_String = "LOW TARGET"
                tLow = True
                tHigh = False
                RangeTarget = Low_Target
                Target = M_Price
                range_identifier = 'Low'
                range_identifier_all = 'All'
                found_Price = HLCC
                tlList = ['LOW TARGET', Low_Target, lowfilled]
                filled = False
                lt_filled = False
                lr_filled = False
                lows_found += 1
                LowRangeFlow += Money_Flow

            if lows_found > 0:
                AvgLowRangeFlow = LowRangeFlow / lows_found
            if highs_found > 0:
                AvgHighRangeFlow = HighRangeFlow / highs_found






        if M_Price == lastMPrice:
            DRC += 1
            Distribution_Price = M_Price
            Cumulutive_DPrice += Distribution_Price
        if M_Price == lastMPrice and qratio >= 30 and LFPC >= .001:
            Resistance = M_Price
        else:
            Resistance = 0

        if M_Price == lastMPrice and mRatio >= 1 and sneakR >= 20:
            Support = M_Price
        else:
            Support = 0

        if M_Price == lastMPrice and sneakR <= 10:
            SketchDist = M_Price
        else:
            SketchDist = 0

        if DRC == 0 and ref_Num >= 2:
            lastDPrice = statistics.mean(mpricelist)
            Weighted_Avg_DPrice = statistics.mean(mpricelist)

        if ref_Num >= 3:
            mpricelist.pop(0)


        if DRC >= 1:
            lastDPrice = Distribution_Price
            if HLCC > Distribution_Price:
                DP_Uptick += 1
                DU += 1
                DP_UptickList.append(DP_Uptick)

            if HLCC < Distribution_Price:
                DD += 1
                DP_Downtick += 1
                DP_DowntickList.append(DP_Uptick)

            Avg_DPrice = round(Cumulutive_DPrice / DRC, 2)
            if DRC < 2:
                Weighted_Avg_DPrice = round(((lastDPrice + Avg_DPrice + avgMPrice) / 3), 2)

        if DRC >= 2:
            Weighted_Avg_DPrice = round(((lastDPrice + Avg_DPrice + avgMPrice) / 3), 2)




        if ref_Num >= 2:
            if Close_Price < Open_Price:
                DOWN_c += .25
                if OC_Range > avg_OC_Range:
                    pg_down_var += .25
                    if OC_Range >= avg_HL_Range:
                        pg_down_var += .5
            if M_Price < lastMPrice and lastMPrice >= Last:
                DOWN_c += .25
            if Close_Price < Last:
                DOWN_c += .25
            if Close_Price < lastLPrice:
                DOWN_c += .25
            if Low_Price <= LOD:
                pg_down_var += .25


            if Close_Price < round((avgMPrice + Weighted_Avg_DPrice) / 2, 2):
                pg_down_var += .25
            if High_Price <= Weighted_Avg_DPrice:
                pg_down_var += .25
            if abs(Close_Price - Open_Price) < abs(M_Price - lastMPrice):
                pg_down_var += .25


            if Close_Price > Open_Price:
                UP_c += .25
                if OC_Range > avg_OC_Range:
                    pg_up_var += .25
                    if OC_Range >= avg_HL_Range:
                        pg_up_var += .5
            if M_Price > lastMPrice and lastMPrice <= Last:
                UP_c += .25
            if Close_Price > Last:
                UP_c += .25
            if Close_Price > lastHPrice:
                UP_c += .25


            if Close_Price > round((avgMPrice + Weighted_Avg_DPrice) / 2, 2):
                pg_up_var += .25
            if High_Price >= HOD:
                pg_up_var += .25
            if Low_Price >= Weighted_Avg_DPrice:
                pg_up_var += .25
            if abs(Close_Price - Open_Price) > abs(M_Price - lastMPrice):
                pg_up_var += .25




            if HLCC < lastLPrice:
                if High_Price <= lastHPrice:
                    DownTicks += 1
                DownTicks += 1
                DOWN_IV += round(round(Close_Price - Last, 2) - avg_HL_Range, 2)

            if HLCC > lastHPrice:
                if Low_Price >= lastLPrice:
                    UpTicks += 1
                UpTicks += 1
                UP_IV += round(round(Close_Price - Last, 2) + avg_HL_Range, 2)

        if Low_Price <= lastLPrice and Close_Price >= Last:
            hs_up += 1
        if High_Price >= lastHPrice and Close_Price <= Last:
            hs_down += 1
        if hs_up > 0 and hs_down > 0:
            hidden_strength = round(hs_up / hs_down, 2)

        if DOWN_c > 0 and UP_c > 0:
            PainGauge = round((DOWN_c + pg_down_var) / (UP_c + pg_up_var), 3)
            if DOWN_c >= 1 and UP_c >= 1:
                Avg_Up_Move = round(UP_IV / UP_c, 2)
                Avg_Down_Move = round(DOWN_IV / DOWN_c, 2)
                Avg_Move = round(100*(DOWN_IV + UP_IV) / Close_Price, 2)
                # Avg_Move = round(Avg_Move1 * 100, 2)

                PainGaugePct = round(100-100*abs(PainGauge - .637) / 1.529, 2)
                # BB_Strength = round(DOWN_c / DOWN_IV, 2) + round(UP_c / UP_IV, 2)

        else:
            PainGauge = 1

        PG = PainGauge


        if DU >= 1 and DD >= 1:
            DR = round(DU / DD, 2)


        if M_Price > lastMPrice:
            mticksymbol = Fore.GREEN+'∆'
            MUTick += 1
            MT += 1
            if HLCC > Last:
                MUTick += 1
                MT += 1
                if HLCC > M_Price:
                    MTR_copy += round(High_Price - Low_Price, 2)
        if M_Price < lastMPrice:
            mticksymbol = Fore.RED+'◊'
            MDTick += 1
            MT += 1
            if HLCC < Last:
                MDTick += 1
                MT += 1
                if HLCC < M_Price:
                    MTR_copy += round(Low_Price - High_Price, 2)
        if M_Price == lastMPrice:
            if DRC >= 2:
                if M_Price > lastDPrice:
                    MUTick += 1
                    MT += 1
                if M_Price < lastDPrice:
                    MDTick += 1
                    MT += 1

            else:
                pass






        if MUTick >= 1 and MDTick >= 1:
            MTR = round(MUTick / MT, 3)

        if MTR >= .5:
            MTR_s += 1
        if MTR <= .5:
            MTR_s += -1



        if abs(MTR_s) >= 1:
            MTR_Strength = 100*round(MTR_s / ref_Num, 3)



        if ref_Num >= 2:

            if Open_Price > Last:
                gapUp += 1
                gapUpDistance += round(Open_Price - Last, 2)

            elif Open_Price < Last:
                gapDown += 1
                gapDownDistance += round(abs(Open_Price - Last), 2)

        if gapUp >= 1 and gapDown >= 1:
            gapRatio = round(gapUp / gapDown, 3)
            gapDistanceRatio = round(gapUpDistance / gapDownDistance, 2)
            if ref_Num < 390:
                volatility_index = round((gapUpDistance + gapDownDistance + gapUp + gapDown) / abs(390-ref_Num), 2)
            else:
                volatility_index = round((gapUpDistance + gapDownDistance + gapUp + gapDown) / 390, 2)

        if M_Price > High_Price:
            TradingAbove_Count += 1
            TradingAbove_Diff += round(abs(M_Price - High_Price), 2)

        if M_Price < Low_Price:
            TradingBelow_Count += 1
            TradingBelow_Diff += round(abs(M_Price - Low_Price), 2)

        if TradingAbove_Count >= 1 or TradingBelow_Count >= 1:
            TATBR_Sum = round(100*(TradingAbove_Diff - TradingBelow_Diff) / Close_Price, 2)


        if abs(MIV_Index) >= .25 and ref_Num > 1:
            MIV_Spike += abs(MIV_Index)
            MIV_Spike_Count += 1
            MIV_Spike_List.append(abs(MIV_Index))
            Avg_MIV_Spike = round(MIV_Spike / MIV_Spike_Count, 3)
        if abs(MIV_Index) >= .25 and ref_Num > 1:
            Avg_MIV_Spike_String = str(Avg_MIV_Spike)


        newratio = round(10*(LFP * LFPC), 3)


        if Close_Price >= Open_Price and Liq_change > 0:
            UpTicks += 1
            Price_Tick = 1
            Liq_Tick = 1
            BuyVolume += f_Vol
            BuyPower += Liq_change
            ShortPower += Liq_change * -1




            PULQ = False
        elif Close_Price >= Open_Price and Liq_change < 0:
            Price_Tick = 0
            Liq_Tick = -1
            ShortVolume += f_Vol
            BuyVolume += Liq_change * -1
            ShortPower += Liq_change * -1
            ShortVolumeTotal += f_Vol
            ShortMoney += Money_Flow
            ShortCount += 1
            ShortLiquidity += abs(Liq_change)
            S_Price += HLCC

            PULQ = True
        elif Close_Price <= Open_Price and Liq_change > 0:
            Price_Tick = -1
            Liq_Tick = 0
            ShortPower += Liq_change
            # BuyPower += Liq_change
            SellPower += Liq_change
            CoverVolumeTotal += f_Vol
            CoverMoney += Money_Flow
            CoverCount += 1
            CoverLiquidity += Liq_change
            C_Price += HLCC


            PULQ = False
        elif Close_Price <= Open_Price and Liq_change < 0:
            Price_Tick = -1
            Liq_Tick = -1
            SellVolume += f_Vol
            SellPower += abs(Liq_change)
            DownTicks += 1





            PULQ = False
        Price_Tick_Total += Price_Tick
        Liq_Tick_Total += Liq_Tick
        if abs(Price_Tick_Total) >= 1 and abs(Liq_Tick_Total) >= 1:
            PTLT_Ratio = round(abs(Price_Tick_Total) / abs(Liq_Tick_Total), 2)

        if UpTicks >= 1 and DownTicks >= 1:
            UDR = round((UpTicks / DownTicks) - .1, 3)

        if UDR >= 1:
            UDR_s += 1
        if UDR <= 1:
            UDR_s += -1

        if abs(UDR_s) >= 1:
            UDR_Strength = 100 * round(UDR_s / ref_Num, 3)


        Tick = Liq_Tick + Price_Tick
        Strength += Tick
        percent_Strength = round(Strength / ref_Num, 4)
        step1 = -210 * ref_Num
        step2 = step1 / 390
        step3 = Strength / 390
        step4 = round(100*(step3 / step2), 4)
        new_Strength = round(100 - (step4 * 100), 2)
        # new_Strength = round(100-(100*abs(percent_Strength- -.3153) / .8794), 2)
        # new_Strength = round(100-(100*abs(percent_Strength - -.305128) / .93333), 2)
        Intraday_Strength = round(100-(100*abs(percent_Strength- -.3333) / .8974), 2)
        adj_Strength = round(100-(100*abs(percent_Strength - -.3053) / .9512), 2)

        LQP_Match = bool


        if qratio < 30 and sneakR < 10 and LFPC >= .001:
            if Liq_change < 0:
                EstimatedPrice = round(Close_Price + (Close_Price * LFPC), 2)

            if Liq_change > 0:
                EstimatedPrice = round(Close_Price - (Close_Price * LFPC), 2)



        if qratio >= 35 and sneakR >= 15 and LFPC >= .001:
            if Liq_change > 0:
                EstimatedPrice = round(Close_Price - (Close_Price * LFPC), 2)

            if Liq_change < 0:
                EstimatedPrice = round(Close_Price + (Close_Price * LFPC), 2)

        if qratio < 20 and sneakR > qratio and LFPC >= .001:
            if Liq_change < 0:
                EstimatedPrice = round(Close_Price - (Close_Price * LFPC), 2)
            if Liq_change > 0:
                EstimatedPrice = round(Close_Price + (Close_Price * LFPC), 2)







        if Liquidity < 0 and Liq_change < 0:
            LQP_Match = True

        if Liquidity > 0 and Liq_change > 0:
            LQP_Match = True


        if Liquidity > 0 and Liq_change < 0:
            LQP_Match = False

        if Liquidity < 0 and Liq_change > 0:
            LQP_Match = False


        with open('/Users/King/Spy_var_analysis.csv', 'a') as csv_file3:
            reader3 = csv.reader(csv_file3)
            wr3 = csv.writer(csv_file3)

            vardatalist = [Date, military_time, ref_Num, Close_Price, chg_Open, PG, MTR, DR, gapRatio, gapDistanceRatio, PivotSpread, avgVol, Intraday_Strength, new_Strength, sneakR_Sum, avgQR, avg_Liq_change, UDR, VSR, QRS_Index, avgVSR, DRC, CashOpen, Liquidity, MTR_Strength, UDR_Strength, avgLFP, chg_45, chg_60, chg_120]
            wr3.writerow(vardatalist)











        if menu_ans == '1' or menu_ans == 'oldfile':
            if Liquidity_Data == 'y':
                PrintInfo = True
                est_diff = round(.01*(100 - LFP), 2)
                est_diff1 = round(LFPC * Close_Price, 2)
                if Liquidity < 0:
                    if Liq_change < 0:
                        est_price = round(est_diff + Close_Price, 2)
                        est_price1 = round(est_diff1 + Close_Price, 2)
                    if Liq_change > 0:
                        est_price = round(Close_Price - est_diff, 2)
                        est_price1 = round(Close_Price + (-1 * est_diff1), 2)
                if Liquidity > 0:
                    if Liq_change < 0:
                        est_price = round(Close_Price - est_diff, 2)
                        est_price1 = round(Close_Price + (-1 * est_diff1), 2)
                    if Liq_change > 0:
                        est_price = round(est_diff + Close_Price, 2)
                        est_price1 = round(est_diff1 + Close_Price, 2)


                sum_Flow += Money_Flow


                avg_HL_Range = sum_HL_Range / ref_Num
                avg_OC_Range = sum_OC_Range / ref_Num
                avg_Liq_change = sum_Liq / ref_Num


                if DRC < 2:
                    if Close_Price > Open_Price:
                        ticksymbolo = Fore.GREEN+Style.BRIGHT+'ˆ'+Style.RESET_ALL
                    if Close_Price < Open_Price:
                        ticksymbolo = Fore.RED+Style.BRIGHT+'ˇ'+Style.RESET_ALL

                if DRC >= 2:
                    if HLCC >= Weighted_Avg_DPrice:
                        ticksymbolo = fg(14)+'ˆ'+rs.all
                    if HLCC <= Weighted_Avg_DPrice:
                        ticksymbolo = fg(227)+'ˇ'+rs.all


                if (M_Price + lastMPrice)  / 2 < (Last + Close_Price) / 2 - (.1 * avg_OC_Range):
                    if lastMPrice >= lastLPrice and lastMPrice <= lastHPrice:
                        ticksymbolc = Fore.GREEN+Style.BRIGHT+'ˆ '+Style.RESET_ALL
                    elif lastMPrice >= lastHPrice and lastMPrice <= lastHPrice + avg_OC_Range:
                        ticksymbolc = Fore.YELLOW+Style.BRIGHT+'∞ '+Style.RESET_ALL




                if (M_Price + lastMPrice)  / 2 > (Last + Close_Price) / 2 + (.1 * avg_OC_Range):
                    if lastMPrice >= lastLPrice and lastMPrice <= lastHPrice:
                        ticksymbolc = Fore.RED+Style.BRIGHT+'ˇ '+Style.RESET_ALL

                    elif lastMPrice <= lastLPrice and lastMPrice >= lastLPrice - avg_OC_Range:
                        ticksymbolc = Fore.YELLOW+Style.BRIGHT+'• '+Style.RESET_ALL





                if abs(MIV_Index) >= .25 and ref_Num > 1:
                    MIV_Spike += abs(MIV_Index)
                    MIV_Spike_Count += 1
                    MIV_Spike_List.append(abs(MIV_Index))
                    Avg_MIV_Spike = round(MIV_Spike / MIV_Spike_Count, 3)
                if abs(MIV_Index) >= .25 and ref_Num > 1:
                    Avg_MIV_Spike_String = str(Avg_MIV_Spike)
                    if MIV_Index > 0:
                        MIV_Index_String = str(round(MIV_Index, 2))
                        print(Fore.BLACK+Back.RED+Style.BRIGHT+'MIV_Index: '+Style.RESET_ALL+Fore.BLACK+Back.RED+'[+'+MIV_Index_String+'%]'+Style.RESET_ALL+Fore.BLACK+Back.RED+Style.BRIGHT+'Avg Spike: '+Style.RESET_ALL+Fore.BLACK+Back.RED+'[+',Avg_MIV_Spike,'%]'+Style.RESET_ALL+Fore.WHITE+'Volume:'+'{:,.2f}'.format(f_Vol)+Style.RESET_ALL)

                    elif MIV_Index < 0:
                        MIV_Index_String = str(round(MIV_Index, 2))
                        print(Fore.BLACK+Back.CYAN+Style.BRIGHT+'MIV_Index: '+Style.RESET_ALL+Fore.BLACK+Back.CYAN+'['+MIV_Index_String+'%]'+Style.RESET_ALL+Fore.BLACK+Back.CYAN+Style.BRIGHT+'Avg Spike: '+Style.RESET_ALL+Fore.BLACK+Back.CYAN+'[',Avg_MIV_Spike,'%]'+Style.RESET_ALL+Fore.WHITE+'Volume:'+'{:,.2f}'.format(f_Vol)+Style.RESET_ALL)




                if abs(Liq_change) > 0:
                    LFP = round(Money_Flow / abs(Liq_change) *.01, 3)
                    LFPC = round(1000 * (abs(Liq_change) / Money_Flow) * .01, 4)

                    if LFP < 13 and LFPC < .085:
                        LFP_WarningStr = 'FKN SELL THIS SHIT SON  %s' % LFP
                        LFP_WarningStr_clr = colored(LFP_WarningStr, 'red', attrs=['bold','blink'])
                        # print(LFP_WarningStr_clr)

                    if LFP < 20 and LFP > 13:
                        LFP_WarningStr = 'FKN BUY THIS SHIT SON %s' % LFP
                        LFP_WarningStr_clr = colored(LFP_WarningStr, 'cyan', attrs=['bold','blink'])
                        # print(LFP_WarningStr_clr)


                #     if Money_Flow > 0 and lastFlow > 0:
                #         if f_Vol > 0 and lastVol > 0:
                #             M_index = round(100*(Money_Flow / lastFlow), 3)
                #             V_index = round(100*(f_Vol / lastVol), 3)
                #             new_MIV = round(M_index - V_index, 3)
                #     avgVol = sumVol / ref_Num

                #
                #     if new_MIV >= .15 and OC_Range < avg_HL_Range:
                #         WarningString = Fore.CYAN+'BULLISH MV'
                #         print(WarningString)
                #
                #     if new_MIV <= -.15 and OC_Range < avg_HL_Range:
                #         WarningString = Fore.RED+'BEARISH MV'
                #         print(WarningString)







                SS = str(new_Strength)
                abs_Liq = abs(Liq_change)
                counter += 1



                if ShortCount >= 1:
                    ShortPrice = round(S_Price / ShortCount, 2)

                if CoverCount >= 1:
                    CoverPrice = round(C_Price / CoverCount, 2)


                if ref_Num < 10:
                    AvgStrengthReference += new_Strength
                if ref_Num == 20:
                    AvgStrengthReference = StrengthReference / ref_Num
                    StrengthReference = AvgStrengthReference
                    counter = 1
                if ref_Num >= 20:
                    counter += 1
                    AvgStrengthReference = AvgStrengthReference + new_Strength

                if counter < 20 and counter >= 1:
                    AvgStrengthReference = AvgStrengthReference / counter
                    StrengthReference = (AvgStrengthReference + new_Strength) / counter

                if counter == 20:
                    counter = counter * 0
                    AvgStrengthReference = AvgStrengthReference * 0 + StrengthReference
                    StrengthReference = StrengthReference




                if M_Price == lastMPrice:
                    WarningString = '!!!'
                    if M_Price < Low_Price:
                        WarningString = Fore.RED+'!!!'
                        mticksymbol = Fore.RED+'x ≈ x'
                        nTS = True
                        Tick_String = fg(185)+bg(235)+'BULLSHIT STOPS HERE'+rs.all+WarningString+'       '
                    if M_Price > High_Price:
                        WarningString = Fore.RED+'!!!'
                        mticksymbol = Fore.RED+'x ≈ x'
                        nTS = True
                        Tick_String = fg(185)+bg(235)+'BULLSHIT STOPS HERE'+rs.all+WarningString+'       '


                    else:
                        mticksymbol = Fore.YELLOW+'≈'
                else:
                    WarningString = ''
                if OC_Range >= avg_HL_Range:
                    if abs(Liq_change) > avg_Liq_change:
                        if Close_Price > Open_Price:
                            WarningString = Fore.CYAN+'[xxx]'+Style.RESET_ALL
                        if Close_Price < Open_Price:
                            WarningString = Fore.RED+'[xxx]'+Style.RESET_ALL
                        else:
                            WarningString = Fore.YELLOW+'[xxx]'

                    else:
                        WarningString = ''


                if PULQ == True and OC_Range <= avg_OC_Range *.3:
                    if abs(Liq_change) < 500 and Liq_change < 0:
                        if abs(Liq_change) < avg_Liq_change * .05:
                            WarningString = '[*]'
                        else:
                            WarningString = ''


                if mRatio >= 1:
                    WarningString = Fore.WHITE+' $'
                    if mRatio > 2:
                        WarningString = Style.RESET_ALL+Style.BRIGHT+' $'
                        if mRatio >= 3:
                            WarningString = Style.RESET_ALL+ef.u+' $$$'+rs.all
                if ref_Num >= 5:
                    OC_RangePct = round(OC_Range / avg_OC_Range * 100, 2)
                    HL_RangePct = round(HL_Range / avg_HL_Range * 100, 2)

                if abs(OC_Range) > 0 and abs(HL_Range) > 0:
                    RangePct = round(OC_Range / (HL_Range / avg_HL_Range) * 1000, 4)
                    OCHL_RangePct = round(OC_Range / HL_Range * 100, 4)
                    OC_HL_RangePctStr = str(OC_HL_RangePct)+'%'
                    OCHL_RangePctStr = str(OC_HL_RangePct)+'%'
                else:
                    OCHL_RangePctStr = ''
                    OC_HL_RangePctStr = ''


                Tick_String = ''
                # if LFP < 100 and LFPC >= .001:
                #     est_diff = round(.01*(100 - LFP), 2)
                #     if Liq_change > 0:
                #         est_price = round(est_diff + Close_Price, 2)
                #     if Liq_change < 0:
                #         est_price = round(Close_Price - est_diff, 2)

                if LFPC > 0:
                    est_diff = round(LFPC * Close_Price, 2)
                    if Liq_change > 0 and Liquidity > 0:
                        est_price = round(est_diff + Close_Price, 2)
                    if Liq_change < 0 and Liquidity < 0:
                        est_price = round(est_diff + Close_Price, 2)
                    if Liquidity > 0 and Liq_change < 0:
                        est_price = round(Close_Price - est_diff, 2)

                else:
                    est_price = M_Price


                if M_Price < lastMPrice and Close_Price < Last:
                    if M_Price - lastMPrice < Close_Price - Last and abs(Close_Price - Last) >= avg_OC_Range:
                        Tick_String = fg(35)+bg(233)+'BULL STRENGTH'+rs.all+WarningString+'          '
                        if M_Price < lastLPrice and M_Price < LOD:
                            Tick_String = fg(159)+bg(233)+'HELLA BULL STRENGTH'+rs.all+WarningString+'          '



                if M_Price - lastMPrice > abs(Close_Price - Last) and Liq_change > 0:
                    Tick_String = fg(0)+bg(226)+ef.u+ef.b+'REVERSAL'+rs.all+WarningString+'          '


                elif M_Price > lastMPrice and Close_Price > Last:
                    if M_Price - lastMPrice < (Close_Price - Last)*.5 and abs(Close_Price - Last) >= avg_OC_Range:
                        Tick_String = fg(188)+bg(21)+ef.b+'BULL ACCELLERATION'+rs.all+WarningString+'          '


                if M_Price > lastMPrice and Close_Price < Last:
                    Tick_String = fg(158)+bg(124)+'BEARISH REVERSAL'+rs.all+WarningString+'           '

                if Liq_change > 0:
                    if M_Price < Close_Price:
                        if LFPC >= .001:
                            Tick_String = fg(220)+bg(0)+'SKETCH AF ALGO UPTICK'+rs.all+WarningString+'            '
                        else:
                            Tick_String = fg(50)+bg(100)+'ALGO UPTICK'+rs.all+WarningString+'            '

                    if M_Price >= Close_Price and M_Price < High_Price + .01:
                        if Close_Price >= Open_Price:
                            Tick_String = Fore.BLUE+Back.GREEN+'UPTICK'+Style.RESET_ALL+WarningString+'               '

                    if M_Price == High_Price or M_Price == lastHPrice:
                        Tick_String = colored('SHORTING HIGH', 'yellow', attrs=['blink'])+Style.RESET_ALL+WarningString+'         '

                if Liq_change < 0:

                    if Close_Price > Open_Price and M_Price < Close_Price:
                        if M_Price < lastMPrice:
                            if abs(M_Price - lastMPrice) >= .5 * avg_OC_Range:
                                Tick_String = colored('FAKEY IMPULSE', 'blue')+Style.RESET_ALL+WarningString+'      '
                            else:

                                Tick_String = colored('EXTENDO SHORT', 'blue')+Style.RESET_ALL+WarningString+'      '
                        else:

                            if OC_Range > avg_HL_Range:
                                Tick_String = fg(11)+bg(60)+'PRICE UP LIQ DOWN'+rs.all+'        '

                            if Close_Price > lastHPrice:
                                if MTR >= .5:
                                    Tick_String = fg(232)+bg(32)+'PRICE UP LIQ DOWN'+rs.all+WarningString+'    '
                                else:
                                    pass

                            else:
                                Tick_String = Fore.WHITE+'PRICE UP LIQ DOWN'+WarningString+'    '
                    else:
                        pass







                if mRatio < .20 and sneakR < 9:                                          ############## THIS IS GOOD
                    if M_Price > High_Price or M_Price >= lastHPrice:                       #####################  THIS IS GOOD
                        Tick_String = colored('DUMP COMING', 'yellow', 'on_red')                ####################### THIS IS GOOD
                        bearTS = True

                    if mRatio < .16 and sneakR < 8:
                        Tick_String = colored('MAX VOLATILITY PUMP & DUMP', 'red', attrs=['bold', 'blink'])
                        bearTS = True

                    else:
                        pass





                else:
                    bearTS = False
                    pass


                if M_Price > High_Price and M_Price > lastHPrice:
                    ta_price = round((Close_Price * LFPC) + Close_Price, 2)
                    if LFPC >= .0013 and LFPC < .002:


                        bullTS = False
                        Tick_String = colored('TRADING ABOVE', 'cyan', 'on_grey')+WarningString+'    ($%s)   ' % ta_price
                    if LFPC >= .002:
                        bullTS = False
                        Tick_String = colored('TRADING ABOVE', 'grey', 'on_cyan')+WarningString+'    ($%s)   ' % ta_price
                else:
                    pass
                if M_Price < Low_Price and M_Price < lastLPrice:
                    tb_price = round(Close_Price - (LFPC * Close_Price), 2)

                    # tb_price = round((Close_Price * (LFPC * -1) + Close_Price), 2)
                    if LFPC >= .0013 and LFPC < .002:
                        Tick_String = colored('TRADING BELOW', 'red', 'on_grey')+WarningString+'    ($%s)   ' % tb_price
                    if LFPC >= .002:
                        Tick_String = colored('TRADING BELOW', 'grey', 'on_red')+WarningString+'    ($%s)   ' % tb_price
                else:
                    pass


                if mRatio >= 2 and Range_Clause == False:
                    if mRatio >= 5:
                        if MIV_Index < 0 and abs(MIV_Index) > Avg_MIV_Spike:
                            if Liq_change > 0:
                                if Liquidity < 0:
                                    Tick_String = Fore.WHITE+Style.BRIGHT+'MASSIVE FKN DUMPING'+Style.RESET_ALL+WarningString+'      '
                                elif Liquidity > 0:
                                    Tick_String = Fore.CYAN+Style.BRIGHT+'MASSIVE FKN BUYING'+Style.RESET_ALL+WarningString+'      '
                            if Liq_change < 0:
                                Tick_String = Fore.WHITE+Style.BRIGHT+Back.RED+'MASSIVE FKN DUMPING'+Style.RESET_ALL+WarningString+'      '
                                bearTS = True

                            else:
                                bearTS = False
                                pass


                        if MIV_Index > 0 and MIV_Index > Avg_MIV_Spike:
                            if Liq_change < 0:
                                Tick_String = Fore.WHITE+Style.BRIGHT+'MASSIVE FKN DUMPING'+Style.RESET_ALL+WarningString+'      '
                                bearTS = True
                            else:
                                bearTS = False
                                pass


                        if abs(MIV_Index) < Avg_MIV_Spike and abs(MIV_Index) < .25:
                            Tick_String = Style.BRIGHT+'MASSIVE FLOW NO MIV'+Style.RESET_ALL+WarningString+'      '

                        else:
                            Tick_String = Style.BRIGHT+Back.YELLOW+Fore.WHITE+'MASSIVE FLOW'+Style.RESET_ALL+WarningString+'      '



                            pass


                    if abs(Liq_change) < .05 * avg_Liq_change:
                        if Open_Price > Last:
                            Tick_String = fg(150)+bg(52)+'ALGOS DOING SOME BEARSHIT'+rs.all

                            # Tick_String = Fore.RED+Style.BRIGHT+Back.WHITE+'ALGOS DOIN SUMBEARSHIT'+Style.RESET_ALL+WarningString+'        '


                    if Close_Price < lastDPrice:
                            if M_Price > lastMPrice and Liq_change < 0:
                                Tick_String = fg(233)+bg(184)+'ALGOS DOIN SOME BULLSHIT'+rs.all

                                # Tick_String = Fore.CYAN+Style.BRIGHT+'ALGOS DOIN SUMBULLSHIT'+Style.RESET_ALL+WarningString+'      '

                            else:
                                pass








                if Liq_change > 0:
                    if Liq_change > avg_Liq_change * 2 and M_Price >= Close_Price + (.75 * avg_HL_Range):
                        if sneakR < 10:
                            bullTS = True
                        if MIV_Index < -.25:
                            Tick_String = colored('BULL EXHAUSTION SETUP', 'cyan', 'on_red')
                            bearTS = True

                        else:
                            Tick_String = colored('BEAR EXHAUSTION SETUP', 'red', 'on_cyan')
                    else:
                        pass
                else:
                    bullTS = False
                    pass

                if Open_Price - Last >= .1 and ref_Num > 2:
                    Tick_String = Fore.BLUE+Style.BRIGHT+'BREAKOUT'+Style.RESET_ALL+WarningString+'     '
                    bullTS = True



                if mRatio >= 1 and sneakR > 100:
                    if M_Price > lastMPrice and Close_Price < Last:
                        Tick_String = colored('LARGE DUMPING', 'white', 'on_red')+WarningString+'       '

                if mRatio < .25 and sneakR < 5:
                    if mRatio < .2 and LFP < 100:
                        if Liq_change > 0:
                            Tick_String = Fore.BLUE+Style.BRIGHT+'BREAKOUT'+Style.RESET_ALL+WarningString+'     '
                            bullTS = True

                        if Liq_change < 0:
                            Tick_String = Fore.YELLOW+Style.BRIGHT+'BREAKDOWN'+Style.RESET_ALL+WarningString+'     '
                            bearTS = True
                        else:
                            Tick_String = Fore.RED+Back.YELLOW+Style.BRIGHT+'VOLATILITY COMING'+Style.RESET_ALL+WarningString+'     '
                            nTS = True


                    else:
                        bearTS = False
                        bullTS = False
                        nTS = False
                        pass

                else:
                    nTS = False
                    bearTS = False
                    bullTS = False
                    pass


                if OC_Range > avg_OC_Range and f_Vol < avgVol * .3 and HL_Range > avg_HL_Range:
                    if Close_Price < Open_Price and Close_Price < M_Price:
                        Tick_String = Fore.RED+Style.BRIGHT+'SKETCHY SELLING'+Style.RESET_ALL+WarningString+'         '

                    if Close_Price > Open_Price and Close_Price > M_Price:
                        Tick_String = Fore.GREEN+Style.BRIGHT+'SKETCHY BUYING'+Style.RESET_ALL+WarningString+'        '






                # if Open_Price > Last and mRatio < .15:
                #     Tick_String = colored('PUMP N DUMP V2', 'yellow', attrs=['blink'])
                #     bearTS = True
                #
                # else:
                #     pass

                if sneakR >= 20 and mRatio < 1:
                    if Liq_change < 0 and mRatio >= .6:
                        if LFP < 500:
                            if est_price < Close_Price:
                                price_str = str(est_price)
                                Tick_String = 'PROBABLY TRADING BELOW'+' ($%s)' % price_str
                            if est_price > Close_Price:
                                price_str = str(est_price)
                                Tick_String = 'PROBABLY TRADING ABOVE'+' ($%s)' % price_str


                        else:
                            pass
                    else:
                        pass



                if mRatio < .18 and sneakR < 10:
                    if LFPC >= .001:
                        if Liquidity < 0:
                            if Liq_change < 0:
                                est_price = round(est_diff + Close_Price, 2)
                                est_price1 = round(est_diff1 + Close_Price, 2)

                            if Liq_change > 0:
                                est_price = round(Close_Price - est_diff, 2)
                                est_price1 = round(Close_Price + (-1 * est_diff1), 2)

                        if Liquidity > 0:
                            if Liq_change < 0:
                                est_price = round(Close_Price - est_diff, 2)
                                est_price1 = round(Close_Price + (-1 * est_diff1), 2)

                            if Liq_change > 0:
                                est_price = round(est_diff + Close_Price, 2)
                                est_price1 = round(est_diff1 + Close_Price, 2)


                        if est_price1 > Close_Price:
                            if M_Price > High_Price:
                                if Liq_change < avg_Liq_change and abs(Liq_change) > 500:
                                    Tick_String = fg(117)+bg(240)+'RELENTLESS BEAR TRAP'+rs.all+WarningString+'      '
                                if Liq_change >= avg_Liq_change:
                                    Tick_String = fg(52)+bg(240)+'RELENTLESS BULL TRAP'+rs.all+WarningString+'      '
                        if est_price1 < Close_Price:
                            Tick_String = fg(52)+bg(240)+'RELENTLESS BULL TRAP'+rs.all+WarningString+'      '
                        nTS = True
                    else:
                        nTS = False
                        pass
                else:
                    nTS = False
                    pass

                if mRatio < .15 and sneakR < 8:
                    if M_Price > High_Price:
                        if Liq_change > avg_Liq_change:
                            est_price = round(-1*(LFPC * Close_Price) + Close_Price, 2)
                            est_price_str = str(est_price)
                            Tick_String = Fore.YELLOW+'GET THE FUCK OUT ($%s)' % est_price_str
                            bearTS = True

                    if M_Price < Low_Price:
                        if abs(Liq_change) > avg_Liq_change:
                            est_price = round(1*(LFPC * Close_Price) + Close_Price, 2)
                            est_price_str = str(est_price)
                            Tick_String = Fore.YELLOW+'MONEY MOVING ($%s)' % est_price_str
                            bullTS = True

                    else:
                        bearTS = False
                        bullTS = False
                        pass





                if Liq_change < 0 and M_Price > Close_Price:
                    if mRatio < .5 and sneakR < 10:
                        Tick_String = colored('MAJOR DOWNTICK', 'yellow', 'on_red', attrs=['bold'])
                        bearTS = True

                    else:
                        pass

                else:
                    bearTS = False

                if sneakR >= 200:
                    Tick_String = fg(184)+bg(17)+'HUGE sneakR (%s)' % sneakR


                if sneakR >= 100 and mRatio >= 3:
                    Tick_String = colored('SERIOUSLY BULLISH', 'white', 'on_blue', attrs=['bold'])
                    bullTS = True

                    if mRatio >= 5:


                        if sneakR / mRatio >= 35 and sneakR > 200:
                            Tick_String = colored('EXTREMELY FKN BULLISH', 'grey', 'on_cyan', attrs=['bold', 'blink'])
                            bullTS = True
                            bearTS = False
                        if sneakR / mRatio <= 15 and Liq_change < 0:
                            Tick_String = bg(100)+bg(153)+fg(95)+fg(160)+'MASSIVE DUMPING <LONG TERM CONFIDENCE (3-5DAYS) ONLY>'+rs.all+WarningString+'     '
                            bearTS = True
                            bullTS = False

                        else:
                            bullTS = False
                            bearTS = False
                            pass
                    else:
                        bullTS = False
                        bearTS = False
                        pass


                else:
                    bullTS = False
                    bearTS = False
                    pass

                if sneakR < 50 and mRatio >= 5:
                    if Close_Price > lastMPrice + avg_HL_Range:
                        Tick_String = colored('TOP CALLA', 'red', 'on_white', attrs=['bold'])
                        bearTS = True
                    if Close_Price < lastMPrice - avg_HL_Range:
                        Tick_String = colored('FOUND THE BOTTOM', 'blue', 'on_cyan')
                        bullTS = True
                else:
                    bullTS = False
                    bearTS = False



                if mRatio >= 1 and mRatio < 1.5:
                    if sneakR >= 60 and Liq_change >= avg_Liq_change:
                        Tick_String = fg(117)+bg(244)+'BUY ENTRY'+rs.all+WarningString+'        '
                        bullTS = True

                    else:
                        pass

                if Open_Price > Last:
                    if mRatio < .175 and sneakR < 10:
                        if Liq_change > 0:
                            est_price = round(1*(LFPC * Close_Price) + Close_Price, 2)
                            Tick_String = fg(0)+bg(118)+'ALGOS WANT IT HIGHER ($'+str(est_price)+')'+fg.rs
                        if Liq_change < 0:
                            est_price = round(-1*(LFPC * Close_Price) + Close_Price, 2)
                            Tick_String = fg(0)+bg(94)+'ALGOS WANT IT LOWER ($'+str(est_price)+')'+rs.all
                    else:
                        pass

                if sneakR >= 20 and mRatio < .35:
                    if ref_Num >= 2 and lastmRatio < 1:
                        Tick_String = fg(197)+bg(235)+'$ BEING PUT TO WORK $'+rs.all+WarningString+'      '
                        bullTS = True
                    else:
                        bullTS = False
                        pass




                if mRatio >= 3 and sneakR / mRatio <= 10:
                    if mRatio >= qratio:
                        if Liquidity > 0:
                            Tick_String = fg(16)+bg(213)+'MASSIVE BUYING <LONG TERM CONFIDENCE ONLY>'+rs.all+WarningString+'     '
                            bullTS = True
                            bearTS = False
                        if Liquidity < 0 or Liquidity - Liq_change < 0:
                            Tick_String = bg(100)+bg(153)+fg(95)+fg(160)+'MASSIVE SHORT COVERING <LONG TERM CONFIDENCE ONLY>'+rs.all+WarningString+'     '
                            bearTS = True
                            bullTS = False
                    else:
                        bearTS1 = False
                        bullTS = False
                        bearTS = False


                else:
                    bearTS1 = False

                if Liquidity < 0:
                    if Liq_change <= avg_Liq_change and Liq_change > 0:                                            #################
                        Tick_String = fg(169)+bg(0)+'PIRANAHS BITING'+rs.all+WarningString+'        '           #################
                    if Liq_change > avg_Liq_change * 2 and Liq_change > 0:
                        if mRatio >= 1 and mRatio < 3:
                            Tick_String = fg(153)+bg(88)+ef.u+'MASSIVE SHORT COVERING RALLY'+rs.all+WarningString+'        '
                            bullTS = True
                            bearTS1 = False
                        if mRatio >= 3:
                            Tick_String = fg(158)+bg(235)+'DANGEROUS SHORT COVERING'+rs.all+WarningString+'       '       ##############
                            bearTS1 = True
                            bullTS = False

                    else:
                        bullTS = False
                        bearTS1 = False
                        pass

                if sneakR >= 25 and new_sneakR / sneakR < 1.1:
                    if mRatio < .5:
                        if Liquidity > 0:
                            Tick_String = fg(118)+bg(234)+'BULLISH ACCUMULATION'+rs.all+WarningString+'        '
                        if Liquidity < 0:
                            Tick_String = fg(96)+fg(17)+bg(103)+bg(141)+'BEARISH ACCUMULATION'+rs.all+WarningString+'        '
                if Liq_change < 0 and Close_Price < Open_Price:
                    if Close_Price < lastLPrice and abs(Liq_change) > avg_Liq_change + (avg_Liq_change * .2):
                        if Intraday_Strength >= new_Strength:
                            Tick_String = fg(50)+bg(243)+'REDBULL RALLY'+rs.all+WarningString+'        '
                            bullTS = True
                        if new_Strength < Intraday_Strength:
                            Tick_String = fg(255)+bg(52)+'BEARS RUN IT'+rs.all+WarningString+'        '
                            bullTS = False
                            bearTS = True





                    else:
                        bullTS = False
                        bearTS = False
                        pass


                if DR >= 4:
                    extremeDR = True
                else:
                    extremeDR = False

                if gapRatio >= 5:
                    extremeGR = True
                else:
                    extremeGR = False


                if LFPC >= .002 and Range_Clause == False:
                    if mRatio >= .2 and sneakR < 10:
                        if Liq_change > 0 and M_Price > lastMPrice:
                            bullTS = True
                            bearTS = False
                            est_diff = LFPC * Close_Price
                            est_price = round(est_diff + Close_Price, 2)
                            Tick_String = fg(159)+'MASSIVE BUYING '+str(est_price)+rs.all+WarningString+'     '+str(M_Price_clone)


                        if Liq_change < 0 and M_Price < lastMPrice:
                            bearTS = True
                            bullTS = False
                            est_diff = (LFPC * -1) * Close_Price
                            est_price = round(est_diff + Close_Price, 2)
                            Tick_String = fg(154)+'MASSIVE SELLING '+str(est_price)+rs.all+WarningString+'     '

                        else:
                            bearTS = False
                            bullTS = False

                    else:
                        bearTS = False
                        bullTS = False


                if LFPC >= .01:
                    if newratio >= 1 and qratio < 10:
                        if Liq_change > 0:
                            Tick_String = fg(167)+fg(134)+bg(59)+'ALGOS BIGLY SELLERS'+rs.all+WarningString+'      '
                        if Liq_change < 0:
                            Tick_String = fg(156)+fg(84)+'ALGOS BIGLY BUYERS'+rs.all+WarningString+'        '


                if qratio < 10:
                    if Liq_change > 0 or MIV_Index > 0:
                        Tick_String = fg(9)+bg(235)+'QRATIO = '+str(qratio)+rs.all+WarningString+'           '

                    if Liq_change < 0 or MIV_Index < 0:
                        Tick_String = fg(51)+bg(234)+'QRATIO = '+str(qratio)+rs.all+WarningString+'           '

                if qratio >= 80 and Liq_change > 0:
                    Tick_String = fg(9)+bg(235)+'QRATIO = '+str(qratio)+rs.all+WarningString+'           '
                    bearTS = True
                    bullTS = False

                elif qratio >= 150:
                    Tick_String = fg(214)+bg(234)+'MASSIVE QRATIO ['+str(qratio)+']'+rs.all+WarningString+'           '
                    bearTS = True
                    bullTS = False


                if sneakR < 10 and LFPC >= .0015 and qratio < 20:
                    Tick_String = fg(191)+bg(232)+'BIG MOVE COMING'+rs.all+WarningString+'       '

                if sneakR < 5 and LFPC >= .0015:
                    Tick_String = fg(191)+bg(232)+'BIG MOVE COMING'+rs.all+WarningString+'       '

                if LFPC >= .003:
                    Tick_String = fg(191)+bg(232)+'LARGE LFPC '+str(LFPC)+rs.all+WarningString+'       '



                if sneakR < 5 and qratio < 11 and mRatio < 1:
                    if Liq_change > 0:
                        bearTS = True
                        Tick_String = fg(233)+bg(1)+ef.b+'*BEAR MOVE COMING*'+rs.all+WarningString+'        '

                if sneakR >= 350:
                    Tick_String = fg(227)+bg(55)+'MASSIVE sneakR ['+str(sneakR)+']'+rs.all+WarningString+'          '
                    nTS = True
                    bearTS = False
                    bullTS = False


######################################################################################################################################################


                if sneakR < 5 and qratio < 20 and LFPC == 0:
                    extremeBullTS = True
                    Tick_String = fg(192)+bg(17)+'BULL SIGNAL (VOLATILITY COMING)'+rs.all+WarningString+'       '

                if mRatio > 1.5 and LFP < 100:
                    if LQP_Match == False and Liq_change < 0:
                        if qratio < 10 and sneakR < 30:
                            if sneakR > 10 and mRatio >= 2:
                                if BAMS == False:
                                    extremeBullTS = False
                                    extremeBearTS = True
                                    Tick_String = fg(197)+bg(0)+ef.b+ef.u+'*SELL* MAX * CONFIDENCE *'+rs.all+WarningString+'       '
                            if sneakR < 10:
                                if SAMS == False:
                                    extremeBullTS = True
                                    extremeBearTS = False
                                    Tick_String = fg(129)+bg(16)+ef.u+'RIDE THE FKN SKETCH WAVE'+rs.all+WarningString+'     '

                                if SAMS == True:
                                    extremeBullTS = False
                                    extremeBearTS = True
                                    Tick_String = fg(129)+bg(16)+ef.u+'BUY SIGNAL (1) - TOO RISKY (SAMS)'


                if qratio > sneakR and qratio < 10:
                    if LFPC >= .0015:
                        extremeBullTS = False
                        extremeBearTS = True
                        Tick_String = fg(197)+bg(0)+ef.b+ef.u+'*DUMB SELLING*SMART BUYING* (1)'+rs.all+WarningString+'       '


                if qratio <= 4 and Liq_change > 0 and LFPC >= .001 and ref_Num >= 3:
                    extremeBullTS = False
                    extremeBearTS = True
                    Tick_String = fg(197)+bg(0)+ef.b+ef.u+'*SELL THE RALLY* (2)'+rs.all+WarningString+'       '

                if qratio >= 100 and LFPC >= .001:
                    if M_Price > High_Price:
                        if SAMS == True:
                            FMC = False
                        extremeBearTS = False
                        FMC = True
                        extremeBullTS = False
                        MHOD = False
                        MLOD = False
                        nTS = False

                        Tick_String = fg(191)+bg(236)+ef.b+ef.u+'FAT MOVE COMING (TA)'+rs.all+WarningString+'       '

                    if M_Price < Low_Price:
                        extremeBearTS = True
                        extremeBullTS = False
                        MHOD = False
                        MLOD = False
                        nTS = False
                        Tick_String = fg(191)+bg(236)+ef.b+ef.u+'FAT MOVE COMING (TB)'+rs.all+WarningString+'       '






                if sneakR > 100 and LFPC >= .0015:
                    if Range_Clause == False:
                        if qratio >= 35:
                            if SAMS == False:
                                extremeBullTS = True
                                extremeBearTS = False
                                Tick_String = fg(129)+bg(16)+ef.u+'RIDE THE FKN SKETCH WAVE'+rs.all+WarningString+'     '

                            if SAMS == True:
                                extremeBullTS = False
                                extremeBearTS = True
                                Tick_String = fg(129)+bg(16)+ef.u+'BUY SIGNAL (2) - TOO RISKY (SAMS)'
                        # if qratio < 35:
                        #     if Liq_change < 0:
                        #         extremeBullTS = False
                        #         extremeBearTS = True
                        #         Tick_String = fg(197)+bg(0)+ef.b+ef.u+'*SELL* MAX * CONFIDENCE *'+rs.all+WarningString+'       '
                        #     if Liq_change > 0:
                        #         extremeBearTS = False
                        #         extremeBullTS = True
                        #         Tick_String = fg(129)+bg(16)+ef.u+'RIDE THE FKN SKETCH WAVE'+rs.all+WarningString+'     '


                if LFPC < .001:
                    if sneakR > qratio and sneakR < 10 and mRatio >= 1:
                        bearTS = True
                        bullTS = False
                        Tick_String = Fore.RED+'BIG FKN SELLOFF COMING'+Style.RESET_ALL
                        extremeBullTS = False
                if sneakR < 10 and sneakR >= qratio:




                    if mRatio >= 1 and LFPC >= .001:

                        if SAMS == True:
                            extremeBullTS = False
                            extremeBearTS = True
                            Tick_String = 'BUY SIGNAL - TOO RISKY (SAMS)'

                        if SAMS == False:
                            extremeBullTS = True
                            extremeBearTS = False
                            Tick_String = fg(129)+bg(16)+ef.u+'STUPID RIP COMING'+rs.all+WarningString+'     '

                    if mRatio + qratio < sneakR and LFP < 200:
                        if LFPC < .001 and MIV_Index < 0:
                            if LQP_Match == True:
                                extremeBearTS = True
                                extremeBullTS = False
                                Tick_String = fg(197)+bg(0)+ef.b+ef.u+'*EXTREME BEAR SIGNAL*'+rs.all+WarningString+'       '

                            if LQP_Match == False:
                                extremeBearTS = False
                                extremeBullTS = True
                                Tick_String = fg(156)+bg(232)+ef.b+ef.u+'*POTENTIAL BULL SIGNAL*'+rs.all+WarningString+'       '









                BAMS  = False


                if LFPC >= .0019 and sneakR < 10 and qratio < sneakR:
                    if SAMS == False:
                        extremeBullTS = True
                        extremeBearTS = False
                        Tick_String = fg(156)+bg(234)+ef.b+'*BUY* MAX * CONFIDENCE *'+rs.all+WarningString+'        '

                    if SAMS == True:
                        extremeBullTS = False
                        extremeBearTS = True
                        Tick_String = 'BUY SIGNAL - TOO RISKY (SAMS)'



                if Liq_change < 0 and qratio > 50 and MIV_Index > 2:
                    Tick_String = fg(197)+bg(0)+ef.b+ef.u+'*! SELL * ABSOLUTE * MAX * CONFIDENCE !*'+rs.all+WarningString+'       '
                    extremeBullTS = False
                    SAMS = True
                    extremeBearTS = True
                    nTS = False


                if sneakR < 1:
                    Tick_String = fg(197)+bg(0)+ef.b+ef.u+'*! SELL * ABSOLUTE * MAX * CONFIDENCE !*'+rs.all+WarningString+'       '
                    extremeBullTS = False
                    SAMS = True
                    extremeBearTS = True

                if sneakR < 10 and sneakR >= qratio:
                    if mRatio >= 1.25 or LFPC >= .0015:
                        if Liq_change < 0:
                            extremeBearTS = False
                            extremeBullTS = True
                            # extremeBullTS1 = True
                            Tick_String = fg(129)+bg(16)+ef.u+'STUPID RIP COMING'+rs.all+WarningString+'     '



                        if Liq_change > 0:
                            extremeBearTS = False
                            extremeBullTS = False
                            extremeBullTS1 = True
                            Tick_String = fg(217)+bg(237)+'IFFY FKN RIP COMING'+rs.all+WarningString+'      '
                if ref_Num >= 3:

                    if lastMPrice > HOD and Range_Clause == False:
                        MHOD = True
                        FMC = False
                        MHOD_Price = lastMPrice
                        Tick_String = fg(129)+bg(16)+ef.u+'MONEY ABOVE HOD'+rs.all+WarningString+'     '

                    if lastMPrice < LOD and Range_Clause == False:
                        MLOD = True
                        FMC = False
                        MLOD_Price = lastMPrice
                        Tick_String = fg(129)+bg(16)+ef.u+'MONEY BELOW LOD'+rs.all+WarningString+'     '


                if MHOD == True:
                    if High_Price < MHOD_Price:
                        extremeBearTS = False
                        extremeBullTS = True
                        # extremeBullTS1 = True
                    if High_Price >= MHOD_Price:
                        MHOD = False
                        extremeBearTS = False
                        extremeBullTS = False
                        # extremeBullTS1 = True
                        Tick_String = fg(129)+bg(16)+ef.u+'MHOD PRICE FILLED'+rs.all+WarningString+'     '

                if MLOD == True:
                    if Low_Price > MLOD_Price:

                        extremeBearTS = True
                        extremeBullTS = False
                        # extremeBullTS1 = True
                    if Low_Price <= MLOD_Price:
                        MLOD = False
                        extremeBearTS = False
                        extremeBullTS = False
                        # extremeBullTS1 = True
                        Tick_String = fg(129)+bg(16)+ef.u+'MLOD PRICE FILLED'+rs.all+WarningString+'     '

                if sneakR < 10 and MIV_Index >= 3 and lastVol != 0:
                    lastVol = f_Vol
                    BAMS = True
                    countbam += 1
                    Tick_String = fg(51)+bg(234)+ef.u+Style.BRIGHT+'BUY * ABSOLUTE * MAX * CONFIDENCE *'+rs.all+WarningString+'     '


                if BAMS == True:
                    countbam += 1
                    if countbam >= 2:
                        SAMS = False
                        randfg = random.randint(1, 390)
                        randbg = random.randint(1, 390)
                        extremeBearTS = False
                        bullTS = False
                        bearTS = False
                        SAMS = False
                        Range_Clause = False
                        rFound = False
                        extremeBullTS = False
                        extremeBearTS = False
                        nTS = False
                        bearTS1 = False
                        Tick_String = fg(randfg)+bg(randbg)+'BUY * ABSOLUTE * MAX * CONFIDENCE *'

                # if qratio < 10 and mRatio >= 2 and LFPC >= .0014 and sneakR < 20 and sneakR >= 10 and Liquidity < 0 and LQP_Match == True:
                # YOU NEED TO ADD THIS FOR BULLISH EXTREME SIGNALS^^^^^^^


            # #
            #



            if sneakR < 5 and qratio >= 50:
                SAMS = True
                Tick_String = fg(197)+bg(0)+ef.b+ef.u+'*SHORT TERM SAMS*'+rs.all+WarningString+'       '
                bearTS1 = False
                extremeBearTS = True
                extremeBullTS = False
                bearTS = False
                bullTS = False

            if SAMS == True:
                MHOD = False
                extremeBullTS = False
                FMC = False
                BAMS = False
                extremeBearTS = True

























                Range_List[ref_Num] = Range_Found
                # else:
                    # Tick_String = Fore.WHITE+'PRICE UP LIQ DOWN'+Style.RESET_ALL+WarningString+'                     '+Fore.WHITE+str(Strength)


                        # if abs(Liq_change) <= avg_Liq_change:
                        #     Tick_String = Fore.RED+'SHORT RALLY'+Style.RESET_ALL+WarningString+'            '+Fore.RED+str(Strength)
                        # # else:
                            # Tick_String = Fore.WHITE+'PRICE UP LIQ DOWN'+Style.RESET_ALL+WarningString+'                     '+Fore.WHITE+str(Strength)

                # if Tick == -1 and Liq_Tick == 0:
                #     if Liquidity < 0:
                #         if abs(Liq_change) > avg_Liq_change*2:
                #             Tick_String = Fore.RED+'MM\'s BEARISH'+Style.RESET_ALL+WarningString+'                       '+Fore.YELLOW+str(Strength)
                #         else:
                #             Tick_String = Fore.RED+'SHORT COVERING'+Style.RESET_ALL+WarningString+'                      '+Fore.YELLOW+Back.BLUE+Style.BRIGHT+str(Strength)

                Range_List[ref_Num] = Range_Found
            else:

                # if Range_Clause == True:
                #     if range_ref_String == "HIGH TARGET" and Money_Flow < 300000000:
                #         if Liq_change > 1000000:
                #             print("MARKET MAKER HIGH TARGET")
                #     if range_ref_String == "LOW TARGET" and Money_Flow > 300000000:
                #         if Liq_change < 1000000:
                #             print("MARKET MAKER LOW TARGET")

                if lr_filled == False:
                    if filled == False:
                        if range_ref_String == "LOW TARGET" and Low_Price <= Low_Range:
                            filled_Price = Low_Price
                            time.sleep(pause)
                            print(Fore.WHITE + Back.RED + "LOW RANGE FILLED" + Style.RESET_ALL)
                            time.sleep(1)
                            lr_filled = True
                            lt_filled = False
                            lrf = 1
                            low_Ranges_Filled += lrf
                            if lt_filled == False and lr_filled == True:
                                if Close_Price <= Low_Target:
                                    filled_target_price = Close_Price
                                    time.sleep(pause)
                                    print(Fore.RED + Back.YELLOW + 'LOW TARGET FILLED' + Style.RESET_ALL)
                                    time.sleep(1)
                                    lt_filled = True
                                    filled = True
                                    low_Targets_Filled += 1
                if hr_filled == False:
                    if filled == False:
                        if range_ref_String == "HIGH TARGET" and High_Price >= High_Range:
                            filled_range_price = High_Price
                            time.sleep(pause)
                            print(Fore.CYAN + "HIGH RANGE FILLED" + Style.RESET_ALL)
                            time.sleep(1)
                            hr_filled = True
                            ht_filled = False
                            hrf = 1
                            high_Ranges_Filled += hrf
                            if ht_filled == False and hr_filled == True:
                                if Close_Price >= High_Target:
                                    filled_target_price = High_Price
                                    print(Fore.CYAN + "HIGH TARGET FILLED")
                                    time.sleep(1)
                                    ht_filled = True
                                    filled = True
                                    high_Targets_Filled += 1


            if menu_ans == 'oldfile' or menu_ans == '1':
                if Liquidity_Data == 'y':

                    if rFound == True:
                        if tHigh == True:
                            HRS = str(High_Range)
                            HRT = str(High_Target)
                            LRS = str(Low_Range)
                            LRT = str(Low_Target)
                            MIV_Index_String = str(MIV_Index)

                            print(Fore.YELLOW+'['+Date+']',military_time,Style.RESET_ALL+Fore.BLUE+Back.YELLOW+Style.BRIGHT+'Current Liquidity:'+'{:20,.2f}'.format(Liquidity)+Style.RESET_ALL+Fore.BLUE+Back.YELLOW+Style.BRIGHT+'  Liq Change: '+'{:20,.2f}'.format(Liq_change)+Style.RESET_ALL, Fore.YELLOW+Back.BLUE+Style.BRIGHT,price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+' ]'+Style.RESET_ALL+Tick_String+Style.RESET_ALL+Fore.GREEN+Back.BLUE+Style.BRIGHT+'   NEW HIGH RANGE FOUND:[$'+HRS+']'+'   NEW HIGH TARGET FOUND: [$'+HRT+']'+Fore.WHITE+'     '+MIV_Index_String+'%'+Style.RESET_ALL+Fore.CYAN+'       Avg High Flow: $'+'{:20,.2f}'.format(AvgHighRangeFlow), 'MoneyFlow: $','{:20,.2f}'.format(Money_Flow)+Style.RESET_ALL+Fore.WHITE+'Volume: '+'{:20,.2f}'.format(f_Vol))
                            time.sleep(1)


                        else:
                            tHigh = False
                    else:
                        rFound = False

                    if rFound == True:
                        if tLow == True:
                            HRS = str(High_Range)
                            HRT = str(High_Target)
                            LRS = str(Low_Range)
                            LRT = str(Low_Target)
                            lowFlow = str(AvgLowRangeFlow)
                            flow = str(Money_Flow)
                            MIV_Index_String = str(MIV_Index)

                            Low_Prices = {'LOW RANGE: $': Low_Range, 'LOW TARGET: $': Low_Target}              ##### May not need this line
                            print(Fore.YELLOW+'['+Date+']',military_time,Style.RESET_ALL+Fore.CYAN+Back.RED+Style.BRIGHT+'Current Liquidity:'+'{:20,.2f}'.format(Liquidity)+Style.RESET_ALL+Fore.CYAN+Back.RED+Style.BRIGHT+'  Liq Change: '+'{:20,.2f}'.format(Liq_change)+Style.RESET_ALL, Fore.YELLOW+Back.BLUE+Style.BRIGHT,price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL+' '+Tick_String+Style.RESET_ALL+Fore.CYAN+Back.RED+Style.BRIGHT+'   NEW LOW RANGE FOUND:[$'+LRS+']'+'   NEW LOW TARGET FOUND: [$'+LRT+']'+Fore.WHITE+'     '+MIV_Index_String+'%'+Style.RESET_ALL+Fore.RED+'     Avg Low Flow: $','{:20,.2f}'.format(AvgLowRangeFlow),'MoneyFlow: $','{:20,.2f}'.format(Money_Flow)+Style.RESET_ALL+Fore.WHITE+'Volume: '+'{:20,.2f}'.format(f_Vol))
                            time.sleep(1)

                        else:
                            tLow = False
                    else:
                        rFound = False



                    if bullTS == True:
                        print(Fore.CYAN+ '[' + Date + ']', military_time,PCT_Range_Str,Style.RESET_ALL + Fore.WHITE + Back.BLUE + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.WHITE + Back.BLUE + '  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + Style.RESET_ALL, Fore.WHITE + Back.BLUE + Style.BRIGHT+Style.RESET_ALL+' '+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL + ' '+Tick_String + Style.RESET_ALL + Fore.YELLOW + Back.RED + Style.BRIGHT + Style.RESET_ALL, M_Price)
                        time.sleep(pause)


                    if bearTS == True:
                        print(Fore.RED+ '[' + Date + ']', military_time,PCT_Range_Str,Style.RESET_ALL + Fore.WHITE + Back.RED + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.WHITE + Back.RED + '  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + Style.RESET_ALL, Fore.WHITE + Back.RED + Style.BRIGHT+Style.RESET_ALL+' '+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL + ' '+Tick_String + Style.RESET_ALL + Fore.YELLOW + Back.RED + Style.BRIGHT + Style.RESET_ALL, M_Price)
                        time.sleep(pause)

                    if nTS == True:
                        print(Fore.YELLOW+Style.BRIGHT+fg(123)+bg(236)+ef.u+ '[' + Date + ']', military_time,PCT_Range_Str,Style.RESET_ALL + Fore.YELLOW + Style.BRIGHT+fg(123)+bg(236)+ef.u+'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.YELLOW + Style.BRIGHT+fg(123)+bg(236)+ef.u+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + Style.RESET_ALL, Fore.YELLOW + Style.BRIGHT+fg(123)+bg(236)+ef.u+price_tick_str + ']'+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL + ' '+Tick_String + Style.RESET_ALL + Fore.YELLOW + Back.RED + Style.BRIGHT + Style.RESET_ALL,fg(123)+bg(236)+'Est Price: $',EstimatedPrice,rs.all, M_Price)
                        time.sleep(pause)

                    if bearTS1 == True:
                        print(Fore.YELLOW+Style.BRIGHT+fg(178)+bg(236)+ef.b+ '[' + Date + ']', military_time,PCT_Range_Str,Style.RESET_ALL + Fore.YELLOW + Style.BRIGHT+fg(178)+bg(236)+ef.b+'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.YELLOW + Style.BRIGHT+fg(178)+bg(236)+ef.b+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + Style.RESET_ALL, Fore.YELLOW + Style.BRIGHT+fg(178)+bg(236)+ef.b+price_tick_str + ']'+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL + ' '+Tick_String + Style.RESET_ALL + Fore.YELLOW + Back.RED + Style.BRIGHT + Style.RESET_ALL, M_Price)
                        time.sleep(pause)





                    if bearTS == False and bullTS == False:
                        if nTS == False and bearTS1 == False and Range_Clause == False:
                            if extremeBearTS == True:
                                print(Fore.YELLOW+Style.BRIGHT+bg(233)+fg(88)+ '[' + Date + ']', military_time,PCT_Range_Str, Fore.YELLOW + Style.BRIGHT+fg(233)+fg(88)+'Current Liquidity:' + '{:20,.2f}'.format(Liquidity), Fore.YELLOW + Style.BRIGHT+bg(233)+fg(88)+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change)+ Fore.YELLOW + Style.BRIGHT+bg(233)+fg(88)+' Last Price: '+ef.u+'[$' +str(Close_Price) +']'+rs.all+ticksymbolo+mticksymbol+ticksymbolc+ ' '+Tick_String+ Fore.YELLOW + Back.RED + Style.BRIGHT + Style.RESET_ALL, M_Price)
                                time.sleep(timecounter)

                            elif extremeBullTS == True:
                                print(Fore.YELLOW+fg(46)+bg(234)+ '[' + Date + ']', military_time,PCT_Range_Str, Fore.YELLOW +fg(46)+bg(234)+'Current Liquidity:' + '{:20,.2f}'.format(Liquidity), Fore.YELLOW +fg(46)+bg(234)+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change)+ Fore.YELLOW +fg(46)+bg(234)+' Last Price: [$' + str(Close_Price) + ']'+ticksymbolo+mticksymbol+ticksymbolc+ ' '+Tick_String+ Fore.YELLOW + Back.RED + Style.RESET_ALL, M_Price)
                                time.sleep(timecounter)

                            elif extremeBullTS1 == True:
                                print(Fore.YELLOW+fg(215)+bg(233)+ '[' + Date + ']', military_time,PCT_Range_Str, Fore.YELLOW +fg(215)+bg(233)+'Current Liquidity:' + '{:20,.2f}'.format(Liquidity), Fore.YELLOW +fg(215)+bg(233)+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change)+ Fore.YELLOW +fg(215)+bg(233)+' Last Price: [$' + str(Close_Price) + ']'+ticksymbolo+mticksymbol+ticksymbolc+ ' '+Tick_String+ Fore.YELLOW + Back.RED + Style.RESET_ALL, M_Price)
                                time.sleep(timecounter)

                            elif FMC == True:
                                print(Fore.YELLOW+fg(154)+bg(61)+ '[' + Date + ']', military_time,PCT_Range_Str, Fore.YELLOW +fg(154)+bg(61)+'Current Liquidity:' + '{:20,.2f}'.format(Liquidity), Fore.YELLOW +fg(154)+bg(61)+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change)+ Fore.YELLOW +fg(154)+bg(61)+' Last Price: [$' + str(Close_Price) + ']'+ticksymbolo+mticksymbol+ticksymbolc+ ' '+Tick_String+ Fore.YELLOW + Back.RED + Style.RESET_ALL, M_Price)
                                time.sleep(timecounter)

                            elif BAMS == True:
                                bullTS = False
                                bearTS = False
                                SAMS = False
                                Range_Clause = False
                                rFound = False
                                nTS = False
                                bearTS1 = False
                                extremeBullTS = False
                                extremeBearTS = False
                                MHOD = False
                                MLOD = False
                                print(fg(157)+bg(235)+ '[' + Date + ']', military_time,PCT_Range_Str,Style.RESET_ALL + Fore.YELLOW+fg(157)+bg(235)+'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.YELLOW +fg(157)+bg(235)+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + Style.RESET_ALL, Fore.YELLOW +fg(157)+bg(235)+price_tick_str + ']'+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL + ' '+ef.u+Tick_String + Style.RESET_ALL + Fore.YELLOW + Back.RED + Style.BRIGHT + Style.RESET_ALL, M_Price)




                            else:



                                if mRatio >= .45 and LFPC >= .001:
                                    bg_color_code = bg(57)+bg(236)
                                    bullish_price_str = fg(190)+fg(40)
                                    bearish_price_str = fg(88)+fg(226)
                                    if Liquidity + Liq_change > 0:
                                        if Liq_change > 0:
                                            time.sleep(timecounter)
                                            print(Fore.YELLOW +bg_color_code+fg(191)+'[' + Date + ']', military_time,PCT_Range_Str,fg(94)+fg(154) + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) +bg_color_code+fg(94)+fg(154)+ '  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + ' ' +Style.RESET_ALL+bg_color_code+bullish_price_str+' Last Price: [$'+str(Close_Price)+']'+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL+' '+Tick_String + Style.RESET_ALL+Fore.WHITE+' '+SS+'%'+Style.RESET_ALL,M_Price, ' | ', est_price1)

                                        if Liq_change < 0:
                                            time.sleep(timecounter)
                                            print(Fore.YELLOW +bg_color_code+fg(191)+'[' + Date + ']', military_time,PCT_Range_Str,fg(88)+fg(196) + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) +bg_color_code+fg(88)+fg(196)+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + ' ' +Style.RESET_ALL+bg_color_code+bearish_price_str+' Last Price: ['+str(Close_Price)+']'+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL+ ' '+Tick_String + Style.RESET_ALL+Fore.WHITE+' '+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)



                                    if Liquidity + Liq_change < 0 and Liquidity < 0:
                                        if Liq_change > 0:
                                            time.sleep(timecounter)
                                            print(bg_color_code+fg(191)+'[' + Date + ']', military_time,PCT_Range_Str,fg(88)+fg(196) + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) +bg_color_code+fg(88)+fg(196)+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' +Style.RESET_ALL+bg_color_code+bearish_price_str+'Last Price: ['+str(Close_Price)+']'+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL +' '+Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)

                                        if Liq_change < 0:
                                            time.sleep(timecounter)
                                            print(bg_color_code+fg(191)+'[' + Date + ']', military_time,PCT_Range_Str,fg(94)+fg(154) + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + bg_color_code+fg(94)+fg(154)+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  '  +Style.RESET_ALL+bg_color_code+bullish_price_str+'Last Price: ['+str(Close_Price)+']'+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL + ' '+Tick_String+ Style.RESET_ALL +'     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)

                                else:
                                    if Liq_change < -1000000:
                                            print(Fore.YELLOW + '[' + Date + ']', military_time,PCT_Range_Str,Style.RESET_ALL + Fore.CYAN + Back.RED + Style.BRIGHT + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.YELLOW + Back.RED + Style.BRIGHT + '  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + Style.RESET_ALL, Fore.YELLOW + Back.RED + Style.BRIGHT,price_tick_str +']'+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL + ' '+Tick_String + Style.RESET_ALL + Fore.YELLOW + Back.RED + Style.BRIGHT + '**SELL SIGNAL**' + Style.RESET_ALL, M_Price)
                                            time.sleep(1)
                                    if abs(Liq_change) > 500000:
                                        time.sleep(timecounter)
                                        print(Fore.CYAN + '[' + Date + ']', military_time,PCT_Range_Str,Fore.CYAN + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.YELLOW + Back.BLUE + Style.BRIGHT + ' Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' +Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ ' '+ Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)

                                    if Liquidity < 0:
                                        if Liq_change > 0:
                                            if extremeDR == True:
                                                time.sleep(timecounter)
                                                print(fg(129)+bg(233)+'[' + Date + ']', military_time,PCT_Range_Str+Style.RESET_ALL+Fore.BLUE+ 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL +Fore.WHITE+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' +Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL +' '+Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)
                                            elif extremeGR == True:
                                                time.sleep(timecounter)
                                                print(fg(234)+bg(124)+'[' + Date + ']', military_time,PCT_Range_Str+Style.RESET_ALL+Fore.BLUE+ 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL +Fore.WHITE+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' +Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL +' '+Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)
                                            else:
                                                time.sleep(timecounter)
                                                print(Fore.YELLOW+'[' + Date + ']', military_time,PCT_Range_Str+Style.RESET_ALL+Fore.BLUE+ 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL +Fore.WHITE+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' +Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL +' '+Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)
                                        if Liq_change < 0:
                                            if extremeDR == True:
                                                time.sleep(timecounter)
                                                print(fg(129)+bg(233)+'[' + Date + ']', military_time,PCT_Range_Str+Style.RESET_ALL+Fore.BLUE+ 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL +Fore.CYAN+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' +Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL +' '+Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)
                                            elif extremeGR == True:
                                                time.sleep(timecounter)
                                                print(fg(234)+bg(124)+'[' + Date + ']', military_time,PCT_Range_Str+Style.RESET_ALL+Fore.BLUE+ 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL +Fore.WHITE+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' +Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL +' '+Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)
                                            else:
                                                time.sleep(timecounter)
                                                print(Fore.YELLOW+'[' + Date + ']', military_time,PCT_Range_Str+Style.RESET_ALL+Fore.BLUE+ 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL +Fore.CYAN+'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' +Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL +' '+Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)


                                    if Liquidity > 0:
                                        if Liq_change > 0:
                                            if extremeDR == True:
                                                time.sleep(timecounter)
                                                print(fg(129)+bg(233)+'[' + Date + ']', military_time,PCT_Range_Str,Fore.GREEN + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Fore.GREEN + '  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  '+Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL+ ' '+Tick_String + Style.RESET_ALL+Fore.WHITE+'     '+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)

                                            else:
                                                time.sleep(timecounter)
                                                print(Fore.YELLOW + '[' + Date + ']', military_time,PCT_Range_Str,Fore.GREEN + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Fore.GREEN + '  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  '+Style.RESET_ALL+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL+ ' '+Tick_String + Style.RESET_ALL+Fore.WHITE+'     '+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)

                                        if Liq_change < 0:
                                            if extremeDR == True:
                                                time.sleep(timecounter)
                                                print(fg(129)+bg(233)+'[' + Date + ']', military_time,PCT_Range_Str,Fore.GREEN + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.RED + '  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + Style.RESET_ALL + '  '+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL+ ' '+Tick_String + Style.RESET_ALL+Fore.WHITE+'     '+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)

                                            else:
                                                time.sleep(timecounter)
                                                print(Fore.YELLOW + '[' + Date + ']', military_time,PCT_Range_Str,Fore.GREEN + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.RED + '  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + Style.RESET_ALL + '  '+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+ Style.RESET_ALL+ ' '+Tick_String + Style.RESET_ALL+Fore.WHITE+'     '+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)



                                    # elif Liq_change > 0:
                                    #     time.sleep(timecounter)
                                    #     print(Fore.YELLOW + '[' + Date + ']', military_time,PCT_Range_Str,Fore.BLUE + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.WHITE,'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' + Fore.YELLOW + Back.BLUE,price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL + ' '+Tick_String + Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)
                                    # elif Liq_change < 0:
                                    #     time.sleep(timecounter)
                                    #     print(Fore.YELLOW + '[' + Date + ']', military_time,PCT_Range_Str,Fore.BLUE + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity) + Style.RESET_ALL + Fore.CYAN,'  Liq Change: ' + '{:20,.2f}'.format(Liq_change) + '  ' + Fore.YELLOW + Back.BLUE+price_tick_str+Style.RESET_ALL+ticksymbolo+mticksymbol+ticksymbolc+Style.RESET_ALL + ' '+Tick_String+ Style.RESET_ALL + '     ' + Fore.WHITE+SS+'%'+Style.RESET_ALL, M_Price, ' | ', est_price1)





        if menu_ans == '5' or Liquidity_Data == 'n5':
            import analyze8






        if menu_ans == '4' or Liquidity_Data == 'n4':





            labels = '  Date       Time     Last                LiqChange                Liquidity              $Flow     | $Price | LFP |  LFPC  |EstPrice| Status | mRatio | sneakR | qratio'
            underline = '-------------------------------------------------------------------------------------------------------------------------------------------------------------------------'
            # if M_Price > High_Price or M_Price < Low_Price:

            # if Money_Flow > 0 and abs(Liq_change) > 0:
            #     if qratio >= 35:
            # if Liq_change > 0:
            #     EstimatedPrice = round(Close_Price + (Close_Price * LFPC), 2)
            # if Liq_change < 0:
            #     EstimatedPrice = round(Close_Price - (Close_Price * LFPC), 2)
            #
            #     else:
            #         EstimatedPrice = est_price_x

            if M_Price > High_Price or M_Price < Low_Price:
                if LFPC >= .001 and Range_Clause == False:
                    if sneakR >= 15 and qratio >= 35:
                        if EstimatedPrice >= HOD or EstimatedPrice <= LOD:
                            rawdatalist = [Date, military_time, Close_Price, liqchgstr, liqstr, mf_Str, M_Price, LFP, LFPC, EstimatedPrice, mRatio, sneakR, qratio]
                            rawdatalist.insert(10, Status)
                            rawdatalist1.append(rawdatalist)
                    if qratio < 25:
                        if EstimatedPrice >= HOD or EstimatedPrice <= LOD:
                            if sneakR < 10 or sneakR > qratio:
                                if Liq_change < 0:
                                    EstimatedPrice = round(Close_Price + (Close_Price * LFPC), 2)
                                if Liq_change < 0:
                                    EstimatedPrice = round(Close_Price - (Close_Price * LFPC), 2)
                            rawdatalist = [Date, military_time, Close_Price, liqchgstr, liqstr, mf_Str, M_Price, LFP, LFPC, EstimatedPrice, mRatio, sneakR, qratio]
                            rawdatalist.insert(10, Status)
                            rawdatalist1.append(rawdatalist)

                        else:

                            pass
                    if sneakR > 100 and qratio >= 35:
                        if rawdatalist in rawdatalist1:
                            pass
                        else:

                            rawdatalist1.append(rawdatalist)





        if menu_ans == '6' or menu_ans == 'x' or Liquidity_Data == 'n6' or Liquidity_Data == 'nx':

            newratio = round(10*(LFP * LFPC), 3)
            if abs(Liq_change) > 0:
                LFP = round(Money_Flow / abs(Liq_change) *.01, 3)
                LFPC = round(1000 * (abs(Liq_change) / Money_Flow) * .01, 4)
            est_diff = round(.01*(100 - LFP), 2)
            est_diff1 = round(LFPC * Close_Price, 2)
            if Liquidity < 0:
                if Liq_change < 0:
                    est_price = round(Close_Price - est_diff1, 2)
                    est_price1 = round(est_diff1 + Close_Price, 2)
                if Liq_change > 0:
                    est_price = round(Close_Price + est_diff1, 2)
                    est_price1 = round(Close_Price + (-1 * est_diff1), 2)
            if Liquidity > 0:
                if Liq_change < 0:
                    est_price = round(Close_Price - est_diff1, 2)
                    est_price1 = round(Close_Price + (-1 * est_diff1), 2)
                if Liq_change > 0:
                    est_price = round(est_diff1 + Close_Price, 2)
                    est_price1 = round(est_diff1 + Close_Price, 2)




            # sneakR2_div_sneakR = round(new_sneakR / sneakR, 2)

            mf_Str = '{:20,.2f}'.format(Money_Flow)

            liqstr = '{:20,.2f}'.format(Liquidity)
            liqchgstr = '{:20,.2f}'.format(Liq_change)
            OC_Range = round(OC_Range, 2)
            HL_Range = round(HL_Range, 2)
            sneakR_Sum = round(sneakR_Sum, 2)

            x_desc = '   Time     Date     Price                  LiqChg                Liquidity  $Price WA|DP PG | MTR | DR ITD_BP%/AdjBP%     sneakR_Sum     avgQR     TickGauge'
            if M_Price > High_Price or M_Price < Low_Price and EstimatedPrice != est_price_x:
                if EstimatedPrice > HOD or EstimatedPrice < LOD:
                    EstimatedPrice = EstimatedPrice
                else:
                    EstimatedPrice = 0
            else:
                EstimatedPrice = 0




            rawdatalist = [Date, military_time, Close_Price, liqchgstr, liqstr, mf_Str, M_Price, LFP, LFPC, est_price1, mRatio, sneakR, qratio, EstimatedPrice, QRS_Index]

            # if M_Price > High_Price or M_Price < Low_Price and LFPC >= .001:
            #     if EstimatedPrice > HOD or EstimatedPrice < LOD:
            #         EstimatedPrice = EstimatedPrice
            #     else:
            #         EstimatedPrice = 0
            # else:
            #     EstimatedPrice = 0
                # if sneakR < 10 and qratio < 30:
                #     if Liq_change < 0:
                #         EstimatedPrice_try = round(Close_Price + (Close_Price * LFPC), 2)
                #     if Liq_change > 0:
                #         EstimatedPrice_try = round(Close_Price - (Close_Price * LFPC), 2)
                #
                #     if EstimatedPrice_try > HOD or EstimatedPrice_try < LOD:
                #         EstimatedPrice = EstimatedPrice_try

            #     if sneakR >= 15 and LFPC >= .001 and qratio >= 35:
            #         if EstimatedPrice > HOD or EstimatedPrice < LOD:
            #             EstimatedPrice = EstimatedPrice
            #         else:
            #             EstimatedPrice = 0
            #
            #     else:
            #         EstimatedPrice = 0
            #
            #
            # else:
            #     EstimatedPrice = 0

            ta_tb_diff = round((TradingAbove_Diff - TradingBelow_Diff), 2)




            writedatalist = [ref_Num, Date, military_time[:-3], Close_Price,  M_Price, xString, qratio_div_max, EstimatedPrice, est_price1, MTR, PainGauge, DR, Intraday_Strength, new_Strength, LFP, LFPC, mRatio, sneakR, qratio, sneakR_Sum, avg_sneakR, avgQR, MIV_Spike_Count, avg_Liq_change, lastDPrice, Weighted_Avg_DPrice, Weighted_Movement, UDV, UDR_Ticks, MACD, sneakR_Sum, avg_sneakR, gapRatio, Resistance, Support, chg_Open, Open_Price, High_Price, Low_Price, Liq_change, Liquidity, f_Vol, Money_Flow, MIV_Index, avgVol, MTR_copy, PTLT_Ratio, gapRatio, gapDistanceRatio, PivotSpread, VSR, UDR, SketchDist, runningValueIndex, VIX]
            with open('/Users/King/Spy_data_analysis.csv', 'a') as csv_file2:
                reader2 = csv.reader(csv_file2)
                wr = csv.writer(csv_file2)
                wr.writerow(writedatalist)
            info_datalist = [Date, military_time, Close_Price,'{:10,.2f}'.format(Liq_change), '{:10,.2f}'.format(Liquidity), M_Price, PainGauge, MTR, DR, DRC, gapRatio, gapDistanceRatio, Intraday_Strength, new_Strength, sneakR_Sum, avgQR, '{:2,.2f}'.format(avg_Liq_change), '{:2,.2f}'.format(avgVol), UDR, round(PivotSpread, 2), chg_Open, VIX]

            rawdatalist3.append(info_datalist)
            rawdatalist2.append(rawdatalist)
            # if LFPC >= .0013 and LFP < 60:
            #     rawdatalist2.append(rawdatalist)
    print(labels)
    print(underline)

    for i in rawdatalist1:
        countitems += 1
        print(i)

    if menu_ans == '6' or Liquidity_Data == 'n6':
        for i in rawdatalist2:
            print(i)
        import dprice
        import dprice1

    if menu_ans == 'x' or Liquidity_Data == 'nx':
        print(x_desc)
        for i in rawdatalist3:
            print(i)


    if menu_ans == '7' or Liquidity_Data == 'n7':


        bigFlowbigMovepct = round(100*(LargeFlowCount / (DOWN_c + UP_c)), 2)
        sum_large_LFPC = round((100*sum_large_LFPC) / 2, 3)

        if TradingAbove_Count >= 1:
            TATBR_A = round(TradingAbove_Diff / TradingAbove_Count, 2)

        if TradingBelow_Count >= 1:
            TATBR_B = round(TradingBelow_Diff / TradingBelow_Count, 2)

        if TradingAbove_Count >= 1 and TradingBelow_Count >= 1:
            if TradingAbove_Count >= TradingBelow_Count:
                TATBR = round(TradingAbove_Count / TradingBelow_Count, 2)
                TATBR_diff = round((TradingAbove_Diff / TradingAbove_Count) / (TradingBelow_Diff / TradingBelow_Count), 2)
            if TradingAbove_Count < TradingBelow_Count:
                TATBR = round(TradingBelow_Count / TradingAbove_Count, 2)
                TATBR_diff = round((TradingBelow_Diff / TradingBelow_Count) / (TradingAbove_Diff / TradingAbove_Count), 2)

        print(ef.u+Date, military_time,rs.all+'\n')



        if new_Strength <= Intraday_Strength:
            print(fg(233)+fg(0)+bg(2)+'Adj BP%: ',adj_Strength,'%','    BP%: ',new_Strength,'%'+rs.all)
        print('PTLT Ratio: ',PTLT_Ratio)
        print('U/D Ratio: ',UD_Ratio)
        print('Price Tick Total: ',Price_Tick_Total)
        print('Liq Tick Total: ',Liq_Tick_Total)
        print('Bullish Percentile: ',new_Strength,'%')
        print('IntraDay BP%: ',Intraday_Strength,'%')
        print('Adj BP%: ',adj_Strength,'%')

        sneakR_Sum = round(sneakR_Sum, 2)
        TradingBelow_Diff = round(TradingBelow_Diff, 2)
        TradingAbove_Diff = round(TradingAbove_Diff, 2)
        sneakR_lgst_avg_ratio = round(max(sneakR_log) / avg_sneakR, 3)
        if UpTicks > DownTicks:
            print('Downticks: '+str(DOWN_c)+' | '+str(DownTicks)+'\n'+fg(39)+bg(238)+'Upticks: '+str(UP_c)+' | '+str(UpTicks)+rs.all)
        else:
            print(fg(9)+bg(16)+'Downticks: '+str(DOWN_c)+' | '+str(DownTicks),rs.all+'\n'+'Upticks: '+str(UP_c)+' | '+str(UpTicks)+rs.all)

        if Avg_Up_Move > abs(Avg_Down_Move):
            print(fg(39)+'Avg Up Move: $'+str(avg_up_move_clone)+rs.all,'\n'+'Avg Down Move: $'+str(avg_down_move_clone))
        else:
            if abs(Avg_Down_Move) > Avg_Up_Move:
                print('Avg Up Move: $'+str(avg_up_move_clone)+rs.all,'\n'+fg(9)+'Avg Down Move: $'+str(avg_down_move_clone)+rs.all)
            else:
                print('Avg Up Move: $'+str(avg_up_move_clone)+'\n'+'Avg Down Move: $'+str(avg_down_move_clone))


        print('Avg HL Range: $'+str(avg_HL_Range))
        print('Large Flow Count: ', LargeFlowCount,' (%s' % bigFlowbigMovepct+'%) Of Up/DownTicks')
        if MTR >= .5:
            if MTR >= .55:
                if MTR >= .6:
                    print(fg(39)+bg(238)+'MoneyTickRatio: '+str(MTR)+rs.all)


                else:
                    print(fg(38)+'MoneyTickRatio: '+str(MTR)+rs.all)
            else:
                print(fg(79)+'MoneyTickRatio: '+str(MTR)+rs.all)


        else:
            print(fg(9)+'MoneyTickRatio: ',MTR,rs.all)
        if DR >= 1:
            if DR > 2:
                print(fg(39)+bg(238)+'$ Strength: '+str(DR)+rs.all)
            else:
                print(fg(50)+'$ Strength: '+str(DR)+rs.all)



        if DR < 1:
            print(fg(9)+'$ Strength: '+str(DR)+rs.all)

        if PainGauge < 1:
            if PainGauge < .8:
                print(fg(39)+bg(238)+'PainGauge: %s  (%s' % (PainGauge, PainGaugePct)+'%)',rs.all)
            else:
                print(fg(117)+bg(238)+'PainGauge: %s  (%s' % (PainGauge, PainGaugePct)+'%)',rs.all)

        if PainGauge >= 1:
            print(fg(9)+'PainGauge: %s  (%s' % (PainGauge, PainGaugePct)+'%)',rs.all)


        avg_sneakr_avg_m = round(avg_sneakR / avg_mRatio, 3)

        if avg_sneakr_avg_m >= avg_sneakR:
            if avg_sneakr_avg_m < 25 and avg_sneakR < 20:
                print(ef.u+fg(0)+bg(1)+'Avg sneakR1: ',avg_sneakR,rs.all+'\n'+fg(191)+bg(124)+ef.b+'Avg sneakR / avg mRatio',avg_sneakr_avg_m,rs.all)
            else:

                print(ef.dim+fg(100)+'Avg sneakR1: ',avg_sneakR,rs.all+'\n'+fg(9)+ef.u+'Avg sneakR / avg mRatio',avg_sneakr_avg_m,rs.all)

            # print(ef.dim+'Avg sneakR1: ',avg_sneakR,rs.all+'\n'+fg(50)+ef.u+'Avg sneakR / avg mRatio',avg_sneakr_avg_m,rs.all)
        else:
            print(fg(50)+ef.u+'Avg sneakR1: ',avg_sneakR,rs.all+'\n'+ef.dim+fg(100)+'Avg sneakR / avg mRatio',avg_sneakr_avg_m, rs.all)

        if sneakR_lgst_avg_ratio >= 7:
            print('sneakR lgst:avg:  '+fg(9)+str(sneakR_lgst_avg_ratio)+rs.all)
        else:
            print(fg(123)+bg(90)+ef.u+'sneakR lgst:avg:   '+str(sneakR_lgst_avg_ratio)+rs.all)

        print('Implied Vol: ',Avg_Move,'%')
        print('LFPC Volatility %: ',sum_large_LFPC,'%')

        print('TATBR Sum As % Of Price: ',str(TATBR_Sum)+'%')
        print('Largest Sneak Ratio: ', max(sneakR_log))

        print(ef.u+'Trading Above Count: ', TradingAbove_Count, 'Trading Above $ Total: $', TradingAbove_Diff,rs.all)
        print(ef.u+'Trading Below Count: ', TradingBelow_Count, 'Trading Below $ Total: $', TradingBelow_Diff,rs.all)
        if TradingAbove_Count >= 1 and TradingBelow_Count >= 1:
            if TradingAbove_Count > TradingBelow_Count:
                if TATBR > TATBR_diff:
                    print(ef.dim+'TATBR: ',TATBR,rs.all,'\n'+fg(172)+ef.u+'TATBR Diff: ',TATBR_diff,rs.all)

                if TATBR_diff > TATBR:
                    print(ef.dim+'TATBR: ',TATBR,rs.all,'\n'+fg(39)+ef.u+'TATBR Diff: ',TATBR_diff,rs.all)

            if TradingBelow_Count > TradingAbove_Count:
                if TATBR > TATBR_diff:
                    print(fg(154)+'TATBR: ',TATBR,rs.all,'\n'+fg(17)+bg(154)+ef.u+'TATBR Diff: ',TATBR_diff,rs.all)

                if TATBR_diff > TATBR:
                    print(fg(154)+'TATBR: ',TATBR,rs.all,'\n'+fg(157)+bg(17)+ef.u+'TATBR Diff: ',TATBR_diff,rs.all,)


        print('TATBR_A: ',TATBR_A)
        print('TATBR_B: ',TATBR_B)
        print('GapUps: ',gapUp)
        print('GapDowns: ',gapDown)
        print('UpCount: ',UP_c)
        print('DownCount: ',DOWN_c)



        if gapRatio >= 1:
            if gapRatio >= 1.5:
                print(bg(123)+fg(4)+ef.u+ef.b+'GapRatio: ',gapRatio,rs.all)
            else:
                print(fg(39)+'GapRatio: ',gapRatio,rs.all)

        if gapRatio < 1:
            print(fg(9)+'GapRatio: ',gapRatio,rs.all)
        print('MIV Spike Count: ',MIV_Spike_Count)
        print('Avg MIV Spike',Avg_MIV_Spike,'%')
        print('sneakR_Sum: ',sneakR_Sum)
        if avg_mRatio >= 1:
            print(fg(159)+bg(52)+'Avg mRatio: ',avg_mRatio,rs.all)
        else:
            print('Avg mRatio: ',avg_mRatio)

        print('Avg Liq Change: $','{:5,.2f}'.format(avg_Liq_change))
        if chg_Open > 0:
            print(fg(51)+'% Chg Open: ',chg_Open,'%',rs.all)
        else:
            print(fg(9)+'% Chg Open: ',chg_Open,'%',rs.all)

        liqstr = '{:5,.2f}'.format(Liquidity)
        avg_pct_liq_chg = round(100*(avg_Liq_change / abs(Liquidity)), 3)
        print('Liquidity: $',liqstr)
        print('Avg Liq Change % Liquidity: ',avg_pct_liq_chg,'%')
        if avgQR < 25:
            print(fg(11)+bg(59)+'Avg QR: ',avgQR,rs.all)
        else:
            print(fg(20)+bg(59)+'Avg QR: ',avgQR,rs.all)
        print('PivotPrice: '+PivotStr)
        sum_LFPC = round(sum_LFPC, 4)


        print('SUM LFPC | AVG LFPC: %s | %s' % (sum_LFPC, avg_LFPC))

        print('GapUpDistance: %s' % gapUpDistance)
        print('GapDownDistance: %s' % gapDownDistance)
        print('GDR: %s' % gapDistanceRatio)
        # print('Volatility Index: %s' % volatility_index)
        print('Avg Vol: %s' % avgVol)
        print('VSR: %s' % VSR)
        print('QRS Index: %s' % QRS_Index)
        print('UDR Strength: %s' % UDR_Strength)
        print('MTR Strength %s' % MTR_Strength)
        print('Avg LFP: %s' % avgLFP)
        if VIX < avgVIX:
            print(Fore.CYAN+'VIX: ˇ $%s' % VIX,rs.all)
        if VIX >= avgVIX:
            print(Fore.RED+'VIX: $%s' % VIX, rs.all)

        print(rPVS)



    if menu_ans == '3':
        import tcopy








if PrintInfo == True:


    print('MIV Spike Count: ',MIV_Spike_Count)
    print('Avg MIV Spike',Avg_MIV_Spike,'%')
    print(Fore.CYAN + 'REF#:', ref_Num)
    time.sleep(.25)
    print(Fore.WHITE + Time)
    time.sleep(.25)
    print('Adj BP%: ',adj_Strength,'%')

    print("Last:", "$" + str(Close_Price))
    time.sleep(.25)
    print("HLCC:", "$" + str(HLCC))
    time.sleep(.25)
    if HLCC >= M_Price:
        print(Fore.CYAN+"Money Price: "+" $" + str(round(M_Price, 2))+Style.RESET_ALL)
        time.sleep(.25)
        print(Fore.CYAN+'Price Diff: ' + '$' + str(Diff)+Style.RESET_ALL)

    if HLCC < M_Price:
        print(Fore.RED+"Money Price: "+Fore.RED+" $" + str(round(M_Price, 2))+Style.RESET_ALL)
        time.sleep(.25)
        print(Fore.RED+'Price Diff: ' + '$' + str(Diff)+Style.RESET_ALL)

    time.sleep(.25)
    if f_Vol > 1000000:
        print(Fore.YELLOW + 'Volume:' + '{:20,.2f}'.format(f_Vol))
    else:
        print(Fore.WHITE + 'Volume:' + '{:20,.2f}'.format(f_Vol))
    time.sleep(.25)
    if Money_Flow > 350000000:
        print(Fore.YELLOW + '$Flow:' + '{:20,.2f}'.format(Money_Flow))
    else:
        print(Fore.WHITE + '$Flow:' + '{:20,.2f}'.format(Money_Flow))
    time.sleep(.25)
    if Liq_change < 0:
        print(Fore.RED + 'Liq Change:', '{:20,.2f}'.format(Liq_change), Style.RESET_ALL)
    else:
        print(Fore.CYAN + 'Liq Change:', '{:20,.2f}'.format(Liq_change))
    time.sleep(.25)
    if Liquidity < 0:
        print(Fore.RED + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity), Style.RESET_ALL)
    else:
        print(Fore.CYAN + 'Current Liquidity:' + '{:20,.2f}'.format(Liquidity), Style.RESET_ALL)
    time.sleep(.25)
    print('Avg MIV Spike: ',Avg_MIV_Spike,'%')
    print('Gap Ratio: ',gapRatio)
    if percent_Strength >= -.68:
        percent_Strength_String = Fore.GREEN+'Current Strength: '+str(percent_Strength)+'%'+Style.RESET_ALL
        print(percent_Strength_String)
    if percent_Strength <-.68:
        percent_Strength_String = Fore.RED+'Current Strength: '+str(percent_Strength)+'%'+Style.RESET_ALL
        print(percent_Strength_String)

    # new_Strength = 100-(100*abs(percent_Strength- -.3153) / .8719)
    if new_Strength > 70:
        if Intraday_Strength >= new_Strength:
            print(ef.u+'Adj BP%: ',adj_Strength,'%',rs.all,'\n'+'Bullishness Percentile: '+str(round(new_Strength, 2)))
        else:
            new_Strength_String = Fore.CYAN+'Bullishness Percentile: '+str(round(new_Strength, 2))+'%'+Style.RESET_ALL

    else:
        print('Adj BP%: ',adj_Strength,'%')
        new_Strength_String = Fore.RED+'Bullishness Percentile: '+str(round(new_Strength, 2))+'%'+Style.RESET_ALL

    if PainGauge > 1 or PainGauge < .6:
        if PainGauge >= 1:
            print(fg(232)+bg(196)+'PainGauge: ',PainGauge,rs.all)
        if PainGauge < .6:
            print(fg(87)+bg(4)+'PainGauge: ', PainGauge,rs.all)


    else:
        print('PainGauge: ',PainGauge)

    if Intraday_Strength < 55 or Intraday_Strength > 85:
        if Intraday_Strength > 85:
            print(Fore.CYAN+'IntraDay Strength: ',Intraday_Strength,'%', Style.RESET_ALL)

        if Intraday_Strength < 55:
            print(fg(232)+bg(196)+'IntraDay Strength: ',Intraday_Strength,'%',rs.all)

    else:
        print('IntraDay Strength: ',Intraday_Strength,'%')

    # print('NEWVIX ', newvix)



    if BuyPower > 0 and ShortPower > 0 and SellPower > 0 and SellPower > 0:
        pctShortBuying = round(BuyPower / ShortPower, 4)*100
        pctNetSelling = round(SellPower / ShortPower, 4)*100
        pctNetBuying = round(BuyPower / SellPower, 4)*100
        pctNetBuyingStr = str(pctNetBuying)
        pctNetSellingStr = str(pctNetSelling)
        pctShortBuyingStr = str(pctShortBuying)
        print('Buy Power', '{:5,.2f}'.format(BuyPower), 'Short Power:','{:5,.2f}'.format(ShortPower))
        print('Buy Power as % of Short Selling: ['+pctShortBuyingStr+'%]')
        print('Sell Power as % of Short Selling: ['+pctNetSellingStr+'%]')
        print('Net Buying as % of Net Selling: ['+pctNetBuyingStr+'%]')
        BullBearRatio = abs(round(float(pctShortBuying / pctNetSelling), 4))
        print('Bull Bear Ratio: ',BullBearRatio)
    if UDR < 1:
        print(fg(227)+bg(196)+ef.u+'UpTick/DownTick Ratio: ',UDR,rs.all)
    else:
        print('UpTick/DownTick Ratio: ',UDR)
    if Close_Price >= avgMPrice:

        print(fg(192)+bg(17)+'Money Tick Ratio: '+rs.all+str(MTR)+Fore.GREEN+' ∆'+Style.RESET_ALL)
    else:
        print(fg(16)+bg(220)+'Money Tick Ratio: '+rs.all+str(MTR)+Fore.RED+' ◊'+Style.RESET_ALL)
    if DRC >= 1:
        print('DRC: ', DRC)
        print('Avg Distribution Price: $'+str(Avg_DPrice))
        print('Weighted Avg DPrice: $'+str(Weighted_Avg_DPrice))

        print('Last Distribution Price: $'+str(lastDPrice))
        # print('Resistance: $',max(DP_list))
        # print('Support: $',min(DP_list))
        print('$ Strength: '+str(DR))


    if lows_found >= 1 or highs_found >= 1:
        print('\nLow Ranges/Targets Found|Filled:',lows_found, '| ', low_Ranges_Filled)
        print('\nHigh Ranges/Targets Found|Filled: ',highs_found, '| ', high_Ranges_Filled)
        print('Total found: ',found)
    if hidden_strength > 0:
        print('Hidden Strength: %s' % hidden_strength)
    print('Avg sneakR: %s' % avg_sneakR)
    print('Projected sneakR_Sum EOD: %s' % '{:2,.2f}'.format(projected_ss_eod))
    print('Pivot Spread: $%s' % PivotSpread)
    print('Avg QR: %s' % avgQR)
    print('PVP: ', PVP,'%')
    avgPrice = round(sumFlow / sumVol, 2)
    print('Avg Price: $',avgPrice)

    Style.RESET_ALL




### OTHER COLORS - 45, 94
### 52, 87 (bullish maybe)
### 220, 0 (bearish/volatile maybe
### 236, 16, dope color combo
###197, 232, like a pink on black looks dope
### 171,232
### 122, 53
### 190, 16
### 159, 235
###118, 234
### 246, 237
### 152, 233
### I like 213 and 113 fg
### 15, 161
### 21, 85
### 130, 120, like a pink on green, bullish
### fg 152 is super nice
###122 IDK 234
###51 IDK 16
### 0 IDK 155
### 16 IDK 40
# 209 IDK 233
# 191 IDK 16 < Straight Yellow
# 119 IDK 232 < Straight green
# 143 IDK 246 <-- LIKE A DOPE YELLOW ON DARK GRAY/BLACK
# 236 IDK 160 <-- HELLA BEARISH BLACK ON RED
# 12 IDK 16 < ----- JUST STRAIGHT BLUE, MODEST, BULLISH BLUE

### ABSOLUTE MAX CONFIDENCE , sneakR < 5, qratio <= 10, LFPC >= .002
### QRATIO >= 150
############## 11 / 06 /
######09-20 13:03:00   |    0.093 12.28 132.043 -0.034 0.0034   1,240.75   |    -0.66%   |    -0.55%   |    -0.43%   |    -0.32%   |    -0.7%

# 08-21 12:41:00   |    0.044 0.66 15.0 -0.006 0.0094   1,184.37   |    0.08%   |    0.07%   |    0.0%   |    -0.1%   |    0.15%