A Cutting-Edge Python Obfuscator Engineered for Enhanced Security and Intellectual Property Protection. Safeguard your code with advanced techniques and robust encryption, ensuring it remains confidential and impenetrable to prying eyes.

import base64

import sys

import math

import os

import marshal

import zlib

import random

import time

import ast

import astor

import ctypes

import string

from colorama import Fore, init

init()

__version__ = '1.0.2'

key = random.randint(0, 255)

class clear():
    system = os.name
    if system == 'nt':
        os.system('cls')
    elif system == 'posix':
        os.system('clear')
    else:
        print('\n'*120)

def set_window_title(title):
    ctypes.windll.kernel32.SetConsoleTitleW(title)

system = os.name
if system == 'nt':
    set_window_title(f'RoseGuardian | {__version__}')
    os.system('mode CON: COLS=140 LINES=25')

def slow_print(text, delay=0.1):
    for char in text:
        print(char, end='', flush=True)
        time.sleep(delay)
    print()

def random_name(length=10):
    return ''.join(random.choice(string.ascii_letters) for _ in range(length))

def remove_comments(node):
    for child in ast.walk(node):
        if isinstance(child, ast.FunctionDef):
            child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]
        elif isinstance(child, ast.ClassDef):
            child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]
        elif isinstance(child, ast.AsyncFunctionDef):
            child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]
        elif isinstance(child, ast.Module):
            child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]

def encode_strings(node):
    for child in ast.walk(node):
        if isinstance(child, ast.Str):
            obfuscated = ''.join(f'{ord(c) ^ key:02x}' for c in child.s)
            child.s = obfuscated

def replace_strings_with_decoding(node):
    for child in ast.walk(node):
        if isinstance(child, ast.Assign):
            for target in child.targets:
                if isinstance(target, ast.Name) and isinstance(child.value, ast.Str):
                    obfuscated = child.value.s
                    new_value = ast.Call(
                        func=ast.Name(id='decode_obfuscated_string', ctx=ast.Load()),
                        args=[ast.Str(s=obfuscated)],
                        keywords=[]
                    )
                    child.value = new_value

def remove_blank_lines(node):
    for child in ast.walk(node):
        if hasattr(child, 'body'):
            child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]

def rename_identifiers(node, mapping):
    if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
        node.name = mapping.get(node.name, node.name)

    if isinstance(node, ast.Name):
        node.id = mapping.get(node.id, node.id)

    if isinstance(node, ast.ClassDef):
        node.name = mapping.get(node.name, node.name)

    for child in ast.iter_child_nodes(node):
        rename_identifiers(child, mapping)

def obfuscator1():
    with open(os.path.abspath(sys.argv[1]), 'r') as f:
        slow_print(Fore.RED + 'Reading source code...\n' + Fore.RESET, delay=0.005)
        source_code = f.read()
    
    def random_name():
        return ''.join(random.choices(string.ascii_letters, k=10))

    slow_print(Fore.RED + 'Parsing tree...\n' + Fore.RESET, delay=0.005)

    tree = ast.parse(source_code)

    slow_print(Fore.RED + 'Removing comments...\n' + Fore.RESET, delay=0.005)
    
    remove_comments(tree)
                    
    slow_print(Fore.RED + 'Removing blank lines...\n' + Fore.RESET, delay=0.005)
    
    remove_blank_lines(tree)

    slow_print(Fore.RED + 'Changing class and function names...\n' + Fore.RESET, delay=0.005)
    functions = set()
    classes = set()

    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
            functions.add(node.name)
        elif isinstance(node, ast.ClassDef):
            classes.add(node.name)

    mapping = {name: random_name() for name in functions | classes}

    rename_identifiers(tree, mapping)

    slow_print(Fore.RED + 'Compressing and base64 encoding the marshalized objects...\n' + Fore.RESET, delay=0.005)
    obfuscated_code = base64.b64encode(zlib.compress(marshal.dumps(astor.to_source(tree).encode())))

    return obfuscated_code

def obfuscator0(input_file, output_file):
    with open(input_file, 'r') as file:
        source_code = file.read()

    tree = ast.parse(source_code)

    remove_comments(tree)

    remove_blank_lines(tree)

    encode_strings(tree)

    variables = set()
    functions = set()
    classes = set()

    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
            functions.add(node.name)
        elif isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
            variables.add(node.id)
        elif isinstance(node, ast.ClassDef):
            classes.add(node.name)

    mapping = {name: random_name() for name in variables | functions | classes}

    rename_identifiers(tree, mapping)
    
    with open(output_file, 'w') as file:
        file.write(f"key = {key}\n\n")
        file.write("def decode_obfuscated_string(obfuscated_string):\n")
        file.write("    encoded = bytes.fromhex(obfuscated_string)\n")
        file.write("    decoded = ''.join(chr(b ^ key) for b in encoded)\n")
        file.write("    return decoded\n\n")
        replace_strings_with_decoding(tree)
        file.write(ast.unparse(tree))

def get_junk():

    _1 = '''def morphogenic_adapter():
    pass

class quantum_oscillator:
    def __init__(self):
        self._ = None
        self.__ = None

    def hyperbolic_momentum(self, _):
        return self.hyperbolic_momentum(_)

def tachyon_cascade():
    _ = quantum_oscillator()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def stellar_phase_converter():
    _ = morphogenic_adapter()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def temporal_disruptor():
    pass'''

    _2 = '''def spectral_synthesizer():
    pass

class warp_singularity:
    def __init__(self):
        self._ = None
        self.__ = None

    def temporal_siphon(self, _):
        return self.temporal_siphon(_)

def entropic_fluctuation():
    _ = warp_singularity()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def quantum_reactor():
    _ = spectral_synthesizer()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def graviton_matrix():
    pass
'''

    _3 = '''def quantum_resonator():
    pass

class singularity_nexus:
    def __init__(self):
        self._ = None
        self.__ = None

    def hyperspatial_field(self, _):
        return self.hyperspatial_field(_)

def chronometric_analyzer():
    _ = singularity_nexus()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def gravimetric_capacitor():
    _ = quantum_resonator()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def tachyon_diffractor():
    pass
'''

    _4 = '''def nebula_processor():
    pass

class interstellar_grid:
    def __init__(self):
        self._ = None
        self.__ = None

    def quantum_encoder(self, _):
        return self.quantum_encoder(_)

def cosmic_displacement():
    _ = interstellar_grid()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def subspace_modulator():
    _ = nebula_processor()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def dark_matter_calibrator():
    pass
'''

    _5 = '''def gravimetric_flux():
    pass

class warp_inverter:
    def __init__(self):
        self._ = None
        self.__ = None

    def subspace_transducer(self, _):
        return self.subspace_transducer(_)

def chronal_conduit():
    _ = warp_inverter()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def singularity_stabilizer():
    _ = gravimetric_flux()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def entropic_reactor():
    pass
'''

    _6 = '''def quantum_transmitter():
    pass

class flux_capacitor:
    def __init__(self):
        self._ = None
        self.__ = None

    def tachyon_oscillator(self, _):
        return self.tachyon_oscillator(_)

def spatial_phase():
    _ = flux_capacitor()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def temporal_analyzer():
    _ = quantum_transmitter()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def stellar_modulator():
    pass
'''

    _7 = '''def nebular_computron():
    pass

class cosmic_relay:
    def __init__(self):
        self._ = None
        self.__ = None

    def subspace_coil(self, _):
        return self.subspace_coil(_)

def graviton_amplifier():
    _ = cosmic_relay()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def singularity_catalyst():
    _ = nebular_computron()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def temporal_enigma():
    pass
'''

    _8 = '''def hyperion_mechanism():
    pass

class gravimetric_tensor:
    def __init__(self):
        self._ = None
        self.__ = None

    def warp_crypt(self, _):
        return self.warp_crypt(_)

def quantum_effluvium():
    _ = gravimetric_tensor()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def subspace_resonator():
    _ = hyperion_mechanism()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def temporal_reverberator():
    pass
'''

    _9 = '''def exo_quantum():
    pass

class astro_waveform:
    def __init__(self):
        self._ = None
        self.__ = None

    def flux_capacitance(self, _):
        return self.flux_capacitance(_)

def chrono_stasis():
    _ = astro_waveform()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def gravitic_magnetron():
    _ = exo_quantum()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def subspace_scrambler():
    pass
'''

    _10 = '''def tachyon_entangler():
    pass

class quantum_fusion:
    def __init__(self):
        self._ = None
        self.__ = None

    def warp_induction(self, _):
        return self.warp_induction(_)

def chrono_spectral():
    _ = quantum_fusion()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def gravimetric_anomaly():
    _ = tachyon_entangler()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def subspace_phase_lock():
    pass
'''

    _11 = '''def astral_inverter():
    pass

class stellar_singularity:
    def __init__(self):
        self._ = None
        self.__ = None

    def quantum_nucleus(self, _):
        return self.quantum_nucleus(_)

def hyper_gravimetric():
    _ = stellar_singularity()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def temporal_deflector():
    _ = astral_inverter()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def subspace_injector():
    pass
'''

    _12 = '''def chrono_tesseract():
    pass

class gravimetric_reactor:
    def __init__(self):
        self._ = None
        self.__ = None

    def warp_manifold(self, _):
        return self.warp_manifold(_)

def quantum_vortex():
    _ = gravimetric_reactor()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def astral_siphon():
    _ = chrono_tesseract()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def hyper_flux_analyzer():
    pass
'''

    _13 = '''def warp_oscillator():
    pass

class gravimetric_disruptor:
    def __init__(self):
        self._ = None
        self.__ = None

    def subspace_transmitter(self, _):
        return self.subspace_transmitter(_)

def quantum_chronometer():
    _ = gravimetric_disruptor()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def astral_magnetar():
    _ = warp_oscillator()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def hyperbolic_reactor():
    pass
'''

    _14 = '''def temporal_nexus():
    pass

class quantum_flux:
    def __init__(self):
        self._ = None
        self.__ = None

    def warp_field(self, _):
        return self.warp_field(_)

def stellar_maneuver():
    _ = quantum_flux()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def subspace_chronicle():
    _ = temporal_nexus()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def astral_deflector():
    pass
'''

    _15 = '''def warp_modulator():
    pass

class gravimetric_inverter:
    def __init__(self):
        self._ = None
        self.__ = None

    def quantum_matrix(self, _):
        return self.quantum_matrix(_)

def stellar_entropy():
    _ = gravimetric_inverter()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def temporal_spectral():
    _ = warp_modulator()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def subspace_transmogrifier():
    pass
'''

    _16 = '''def quantum_fissure():
    pass

class stellar_flux:
    def __init__(self):
        self._ = None
        self.__ = None

    def warp_cloak(self, _):
        return self.warp_cloak(_)

def chrono_singularity():
    _ = stellar_flux()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def gravimetric_oscillation():
    _ = quantum_fissure()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def astral_paradigm():
    pass
'''

    _17 = '''def genetic_analyzer():
    pass

class dna_sequencer:
    def __init__(self):
        self._ = None
        self.__ = None

    def genetic_encoder(self, _):
        return self.genetic_encoder(_)

def mutation_inducer():
    _ = dna_sequencer()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_))
'''

    _18 = '''def neural_processor():
    pass

class synaptic_matrix:
    def __init__(self):
        self._ = None
        self.__ = None

    def dendritic_cascade(self, _):
        return self.dendritic_cascade(_)

def cognitive_amplifier():
    _ = synaptic_matrix()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def thought_inhibitor():
    _ = neural_processor()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def consciousness_monitor():
    pass
'''

    _19 = '''def quantum_analyzer():
    pass

class wave_function:
    def __init__(self):
        self._ = None
        self.__ = None

    def entanglement_resolver(self, _):
        return self.entanglement_resolver(_)

def probability_calculator():
    _ = wave_function()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def uncertainty_optimizer():
    _ = quantum_analyzer()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def wave_collapser():
    pass
'''

    _20 = '''def algorithm_optimizer():
    pass

class computational_neuron:
    def __init__(self):
        self._ = None
        self.__ = None

    def synaptic_connection(self, _):
        return self.synaptic_connection(_)

def heuristic_generator():
    _ = computational_neuron()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def pattern_analyzer():
    _ = algorithm_optimizer()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def data_compiler():
    pass
'''

    _21 = '''def audio_processor():
    pass

class waveform_converter:
    def __init__(self):
        self._ = None
        self.__ = None

    def frequency_analyzer(self, _):
        return self.frequency_analyzer(_)

def spectral_filter():
    _ = waveform_converter()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def audio_resampler():
    pass
'''

    _22 = '''def data_encoder():
    pass

class compression_algorithm:
    def __init__(self):
        self._ = None
        self.__ = None

    def data_compressor(self, _):
        return self.data_compressor(_)

def encryption_scheme():
    _ = compression_algorithm()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def data_decoder():
    pass
'''

    _23 = '''def image_processor():
    pass

class color_correction:
    def __init__(self):
        self._ = None
        self.__ = None

    def hue_adjustment(self, _):
        return self.hue_adjustment(_)

def image_filter():
    _ = color_correction()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def image_resizer():
    pass
'''

    _24 = '''def text_analyzer():
    pass

class sentiment_classifier:
    def __init__(self):
        self._ = None
        self.__ = None

    def emotion_analysis(self, _):
        return self.emotion_analysis(_)

def text_summarizer():
    _ = sentiment_classifier()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def text_translator():
    pass
'''

    _25 = '''def financial_analyzer():
    pass

class portfolio_optimizer:
    def __init__(self):
        self._ = None
        self.__ = None

    def risk_assessment(self, _):
        return self.risk_assessment(_)

def investment_strategy():
    _ = portfolio_optimizer()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def asset_alocator():
    pass
'''

    _26 = '''def network_monitor():
    pass

class packet_sniffer:
    def __init__(self):
        self._ = None
        self.__ = None

    def traffic_analyzer(self, _):
        return self.traffic_analyzer(_)

def security_audit():
    _ = packet_sniffer()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def intrusion_detection():
    pass
'''

    _27 = '''def medical_diagnostic():
    pass

class patient_monitor:
    def __init__(self):
        self._ = None
        self.__ = None

    def vital_signs(self, _):
        return self.vital_signs(_)

def disease_classifier():
    _ = patient_monitor()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def treatment_planner():
    pass
'''

    _28 = '''def climate_sensor():
    pass

class temperature_controller:
    def __init__(self):
        self._ = None
        self.__ = None

    def climate_regulator(self, _):
        return self.climate_regulator(_)

def humidity_adjuster():
    _ = temperature_controller()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def air_quality_monitor():
    pass
'''

    _29 = '''def audio_processor():
    return None

class WaveformConverter:
    def __init__(self):
        self.data = None
        self.metadata = None

    def frequency_analysis(self, data):
        return self.frequency_analysis(data)

def SpectralFilter():
    converter = WaveformConverter()
    converter.data = lambda x, y: x(y) + x(x(x(x(y))))

def AudioResampler():
    pass
'''

    _30 = '''def DataEncoder():
    return None

class CompressionAlgorithm:
    def __init__(self):
        self.buffer = None
        self.settings = None

    def CompressData(self, buffer):
        return self.CompressData(buffer)

def EncryptionScheme():
    algorithm = CompressionAlgorithm()
    algorithm.buffer = lambda x, y: x(y) + x(x(x(x(y))))

def DataDecoder():
    pass
'''

    _31 = '''def ImageProcessor():
    return None

class ColorCorrection:
    def __init__(self):
        self.settings = None
        self.mask = None

    def AdjustHue(self, image):
        return self.AdjustHue(image)

def ImageFilter():
    correction = ColorCorrection()
    correction.mask = lambda x, y: x(y) + x(x(x(x(y))))

def ImageResizer():
    pass
'''

    _32 = '''def TextAnalyzer():
    return None

class SentimentClassifier:
    def __init__(self):
        self.model = None
        self.vocab = None

    def AnalyzeEmotion(self, text):
        return self.AnalyzeEmotion(text)

def TextSummarizer():
    classifier = SentimentClassifier()
    classifier.model = lambda x, y: x(y) + x(x(x(x(y))))

def TextTranslator():
    pass
'''

    _33 = '''def FinancialAnalyzer():
    return None

class PortfolioOptimizer:
    def __init__(self):
        self.portfolio = None
        self.strategy = None

    def AssessRisk(self, portfolio):
        return self.AssessRisk(portfolio)

def InvestmentStrategy():
    optimizer = PortfolioOptimizer()
    optimizer.strategy = lambda x, y: x(y) + x(x(x(x(y))))

def AssetAllocator():
    pass
'''

    _34 = '''def complex_processor():
    result = 0
    for i in range(10):
        result += i * (i + 1) / (i + 2)
    return result

class ComplexProcessor:
    def __init__(self):
        self._ = None
        self.__ = None

    def process_data(self, data):
        return self.process_data(data)

def perform_calculation():
    _ = ComplexProcessor()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def simulate_system():
    value = 1
    for _ in range(5):
        value *= value + 1
'''

    _35 = '''def genetic_optimizer():
    result = 1
    for i in range(1, 11):
        result *= i
    return result

class GeneticAlgorithm:
    def __init__(self):
        self._ = None
        self.__ = None

    def optimize(self):
        pass

def calculate_fitness():
    _ = GeneticAlgorithm()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def evaluate_population():
    total = 0
    for i in range(1, 6):
        total += i**2
    return total
'''
   
    _36 = '''def particle_simulator():
    result = 0
    for i in range(1, 21):
        result += i**3 - i**2 + i
    return result

class ParticleSimulator:
    def __init__(self):
        self._ = None
        self.__ = None

    def simulate(self, iterations):
        return self.simulate(iterations)

def simulate_particles():
    _ = ParticleSimulator()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def analyze_data():
    data = [1, 2, 3, 4, 5]
    result = sum(data) / len(data)
'''

    _37 = '''def matrix_multiplier():
    matrix_a = [[1, 2], [3, 4]]
    matrix_b = [[5, 6], [7, 8]]
    result = [[0, 0], [0, 0]]

    for i in range(len(matrix_a)):
        for j in range(len(matrix_b[0])):
            for k in range(len(matrix_b)):
                result[i][j] += matrix_a[i][k] * matrix_b[k][j]

    return result'''

    _38 = '''def newton_raphson():
    def f(x):
        return x**3 - 6 * x**2 + 11 * x - 6

    def df(x):
        return 3 * x**2 - 12 * x + 11

    x0 = 1.0
    for _ in range(5):
        x0 = x0 - f(x0) / df(x0)

    return x0
'''

    _39 = '''def complex_integration():
    def f(x):
        return x**2 + 2 * x + 1

    a = 0
    b = 2
    n = 1000
    h = (b - a) / n

    result = 0
    for i in range(n):
        result += h * (f(a + i*h) + f(a + (i+1)*h)) / 2

    return result
'''

    _40 = '''def random_walk():
    import random

    position = 0
    steps = 1000

    for _ in range(steps):
        if random.random() < 0.5:
            position += 1
        else:
            position -= 1

    return position'''

    _41 = '''def monte_carlo_simulation():
    import random

    inside_circle = 0
    total_points = 100000

    for _ in range(total_points):
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)

        if x**2 + y**2 <= 1:
            inside_circle += 1

    return 4 * inside_circle / total_points
'''
    
    _42 = '''def complicated_function():
    result = 0
    for i in range(1, 11):
        result += i**3 - i**2 + i
    return result

class ComplicatedAlgorithm:
    def __init__(self):
        self._ = None
        self.__ = None

    def execute(self):
        pass

def execute_complicated_algorithm():
    _ = ComplicatedAlgorithm()
    _._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))

def analyze_data():
    import random
    
    data = [random.randint(1, 100) for _ in range(10)]
    result = sum(data) / len(data)
'''
    
    _43 = '''def hard_equation_solver():
    result = 0
    for i in range(1, 11):
        result += i**5 - i**4 + i**3 - i**2 + i - 1
    return result

class EquationSolver:
    def __init__(self):
        self._ = None
        self.__ = None

    def solve(self):
        pass

    def quadratic_equation(self, a, b, c):
        discriminant = b**2 - 4*a*c
        if discriminant > 0:
            x1 = (-b + discriminant**0.5) / (2*a)
            x2 = (-b - discriminant**0.5) / (2*a)
            return x1, x2
        elif discriminant == 0:
            x = -b / (2*a)
            return x
        else:
            real_part = -b / (2*a)
            imaginary_part = (abs(discriminant)**0.5) / (2*a)
            return (real_part + imaginary_part * 1j, real_part - imaginary_part * 1j)

    def integrate_polynomial(self, coefficients):
        result = [coeff / (i+1) for i, coeff in enumerate(coefficients)]
        result.append(0)
        return result

def solve_equation():
    _ = EquationSolver()
    _.quadratic_equation(1, -3, 2)

def compute_fibonacci(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return compute_fibonacci(n-1) + compute_fibonacci(n-2)
'''

    _44 = '''def junk_function_1():
    result = 0
    for i in range(1, 6):
        result += i**3 - i**2 + i - 1
    return result

class RandomEquationSolver:
    def __init__(self):
        self.a = 5
        self.b = 3

    def solve(self):
        return self.a * self.b + self.a - self.b

    def random_operation(self):
        return self.a**2 + self.b**3 - self.a * self.b

def solve_random_equation():
    solver = RandomEquationSolver()
    return solver.solve()

def compute_random_sequence(length):
    return [i**2 - i + 1 for i in range(length)]

def find_random_factors(n):
    factors = []
    while n % 2 == 0:
        factors.append(2)
        n = n // 2
    for i in range(3, int(n**0.5) + 1, 2):
        while n % i == 0:
            factors.append(i)
            n = n // i
    if n > 2:
        factors.append(n)
    return factors

def calculate_random_gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def generate_random_points(num_points):
    points = []
    for _ in range(num_points):
        x = 2 * _ + 1
        y = 3 * _ + 2
        points.append((x, y))
    return points
'''

    _45 = '''def multiply_matrices(mat1, mat2):
    result = []
    for i in range(len(mat1)):
        row = []
        for j in range(len(mat2[0])):
            total = 0
            for k in range(len(mat2)):
                total += mat1[i][k] * mat2[k][j]
            row.append(total)
        result.append(row)
    return result
'''

    return random.choice([_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45])

def write_code():
    obfuscated_file = os.path.join(os.getcwd(),  'obfuscated_' + f"{os.path.basename(os.path.abspath(sys.argv[1]))}")

    with open(os.path.join(obfuscated_file), 'w') as f:

        if (len(sys.argv) > 2 and sys.argv[2].isdigit()):

            f.write("""__obfuscator__ = 'RoseGuardian'
__author__ = 'gumbobr0t'
__github__ = 'https://github.com/DamagingRose/RoseGuardian'
__license__ = 'EPL-2.0'\n\n""")
            
            slow_print(Fore.RED + 'Junk method detected...\n' + Fore.RESET, delay=0.005)

            slow_print(Fore.RED + 'Pumping first junk layer into code...\n' + Fore.RESET, delay=0.005)
            
            for i in range(math.ceil(int(sys.argv[2])/2)):

                f.write(f'\n{get_junk()}')

        if (len(sys.argv) > 3 and sys.argv[3].isdigit()):
            
            if (sys.argv[3] == '0'):

                slow_print(Fore.RED + 'Obfuscation method 0 detected...\n' + Fore.RESET, delay=0.005)
        
                with open(os.path.abspath(sys.argv[1]), 'r') as file:
                    slow_print(Fore.RED + 'Reading source code...\n' + Fore.RESET, delay=0.005)
                    source_code = file.read()

                slow_print(Fore.RED + 'Parsing tree...\n' + Fore.RESET, delay=0.005)
                tree = ast.parse(source_code)

                slow_print(Fore.RED + 'Removing comments...\n' + Fore.RESET, delay=0.005)
                remove_comments(tree)
                    
                slow_print(Fore.RED + 'Removing blank lines...\n' + Fore.RESET, delay=0.005)
                remove_blank_lines(tree)
    
                slow_print(Fore.RED + 'Encoding strings...\n' + Fore.RESET, delay=0.005)
                encode_strings(tree)

                variables = set()
                functions = set()
                classes = set()

                slow_print(Fore.RED + 'Changing class, function and variable names...\n' + Fore.RESET, delay=0.005)

                for node in ast.walk(tree):
                    if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
                        functions.add(node.name)
                    elif isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
                        variables.add(node.id)
                    elif isinstance(node, ast.ClassDef):
                        classes.add(node.name)

                mapping = {name: random_name() for name in variables | functions | classes}

                rename_identifiers(tree, mapping)

                slow_print(Fore.RED + 'Adding self-decode to strings...\n' + Fore.RESET, delay=0.005)
                f.write(f"\n\nkey = {key}\n\n")
                f.write("def decode_obfuscated_string(obfuscated_string):\n")
                f.write("    encoded = bytes.fromhex(obfuscated_string)\n")
                f.write("    decoded = ''.join(chr(b ^ key) for b in encoded)\n")
                f.write("    return decoded\n\n")
                replace_strings_with_decoding(tree)
                f.write(ast.unparse(tree))

            if (sys.argv[3] == '1'):

                slow_print(Fore.RED + 'Obfuscation method 1 detected...\n' + Fore.RESET, delay=0.005)

                slow_print(Fore.RED + 'Writing obfuscated code to file...\n' + Fore.RESET, delay=0.005)
                
                f.write('\n\nimport marshal, base64, zlib; exec(marshal.loads(zlib.decompress(base64.b64decode(' + repr(obfuscator1()) + '))))')

        if (len(sys.argv) > 2 and sys.argv[2].isdigit()):

            slow_print(Fore.RED + 'Pumping second junk layer into code...\n' + Fore.RESET, delay=0.005)
            
            for i in range(math.ceil(int(sys.argv[2])/2)):

                f.write(f'\n{get_junk()}')

if (len(sys.argv) != 4):
    
    slow_print(Fore.RED + 'Usage: python RoseGuardian.py <filename> <junk layers> <obfuscation method>\n' + Fore.RESET, delay=0.005)
    slow_print(Fore.RED + 'Example: python RoseGuardian.py <your file> 10 1\n' + Fore.RESET, delay=0.005)
    
    sys.exit(0)

if (len(sys.argv) == 4):

    if not os.path.exists(os.path.abspath(sys.argv[1])):
            
        slow_print(Fore.RED + f'File {sys.argv[1]} was not found.\n' + Fore.RESET, delay=0.005)
            
        sys.exit(0)

    if os.path.splitext(os.path.abspath(sys.argv[1]))[1] not in ('.py', '.pyc'):

        slow_print(Fore.RED + f'File {sys.argv[1]} is not a valid python file (.py or .pyc).\n' + Fore.RESET, delay=0.005)
            
        sys.exit(0)

    try:

        write_code()

        slow_print(Fore.RED + f'{sys.argv[1]} -> {"obfuscated_" + f"{sys.argv[1]}"}\n' + Fore.RESET, delay=0.005)

    except Exception as e:
    
        slow_print(Fore.RED + f'Failed to obfuscate {os.path.abspath(sys.argv[1])}.\n\nError: "{e}"\n' + Fore.RESET, delay=0.005)

RoseGuardian.py
DamagingRose/RoseGuardian
import random, string
import base64

def hello():
   
    global var
    
    var = 'hii' # hi
    
    print(var)

print(random.choices(string.ascii_letters, k=5))

hello()

print(base64.b64encode(var.encode('utf-8')))

class banana(): # banana
    ss = b'\nPEWPEW'

    print(ss)

def counter(num):

    for i in range(num):

        print('dogs are cool!')

counter(5)

# lalala
test.py
DamagingRose/RoseGuardian