hashcat/src/hashcat.c

/**
 * Author......: See docs/credits.txt
 * License.....: MIT
 */

#if defined (__APPLE__)
#include <stdio.h>
#endif // __APPLE__

#include "common.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <search.h>
#include <inttypes.h>
#include <signal.h>

#if defined (_POSIX)
#include <pthread.h>
#include <pwd.h>
#endif // _POSIX

#include "types.h"
#include "interface.h"
#include "timer.h"
#include "bitops.h"
#include "memory.h"
#include "folder.h"
#include "convert.h"
#include "logging.h"
#include "logfile.h"
#include "ext_OpenCL.h"
#include "ext_ADL.h"
#include "ext_nvapi.h"
#include "ext_nvml.h"
#include "ext_xnvctrl.h"
#include "cpu_aes.h"
#include "cpu_crc32.h"
#include "cpu_des.h"
#include "cpu_md5.h"
#include "cpu_sha1.h"
#include "cpu_sha256.h"
#include "filehandling.h"
#include "tuningdb.h"
#include "thread.h"
#include "opencl.h"
#include "hwmon.h"
#include "restore.h"
#include "hash_management.h"
#include "locking.h"
#include "rp.h"
#include "rp_cpu.h"
#include "rp_kernel_on_cpu.h"
#include "terminal.h"
#include "inc_hash_constants.h"
#include "shared.h"
#include "mpsp.h"
#include "outfile.h"
#include "potfile.h"
#include "debugfile.h"
#include "loopback.h"
#include "data.h"
#include "affinity.h"
#include "bitmap.h"
#include "usage.h"
#include "status.h"
#include "hlfmt.h"
#include "filenames.h"
#include "stdout.h"
#include "dictstat.h"
#include "wordlist.h"
#include "version.h"
#include "benchmark.h"
#include "outfile_check.h"
#include "weak_hash.h"
#include "remove.h"
#include "debugfile.h"
#include "runtime.h"
#include "attack_mode.h"
#include "powertune.h"
#include "autotune.h"
#include "induct.h"
#include "dispatch.h"
#include "monitor.h"
#include "session.h"
#include "user_options.h"

extern hc_global_data_t data;

extern int SUPPRESS_OUTPUT;

extern hc_thread_mutex_t mux_hwmon;
extern hc_thread_mutex_t mux_display;

extern const unsigned int full01;
extern const unsigned int full80;

extern const int DEFAULT_BENCHMARK_ALGORITHMS_BUF[];

const int comptime = COMPTIME;

static void setup_environment_variables ()
{
  char *compute = getenv ("COMPUTE");

  if (compute)
  {
    static char display[100];

    snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);

    putenv (display);
  }
  else
  {
    if (getenv ("DISPLAY") == NULL)
      putenv ((char *) "DISPLAY=:0");
  }

  if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
    putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");

  if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
    putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");

  if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
    putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");

  if (getenv ("CUDA_CACHE_DISABLE") == NULL)
    putenv ((char *) "CUDA_CACHE_DISABLE=1");

  if (getenv ("POCL_KERNEL_CACHE") == NULL)
    putenv ((char *) "POCL_KERNEL_CACHE=0");
}

static void setup_umask ()
{
  umask (077);
}

static void setup_console ()
{
  #if defined (_WIN)
  SetConsoleWindowSize (132);
  #endif
}

static void welcome_screen (const user_options_t *user_options, const time_t *proc_start)
{
  if (user_options->quiet       == true) return;
  if (user_options->keyspace    == true) return;
  if (user_options->stdout_flag == true) return;
  if (user_options->show        == true) return;
  if (user_options->left        == true) return;

  if (user_options->benchmark == true)
  {
    if (user_options->machine_readable == false)
    {
      log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
      log_info ("");
    }
    else
    {
      log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (proc_start));
    }
  }
  else if (user_options->restore == true)
  {
    log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
    log_info ("");
  }
  else
  {
    log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
    log_info ("");
  }
}

static void goodbye_screen (const user_options_t *user_options, const time_t *proc_start, const time_t *proc_stop)
{
  if (user_options->quiet       == true) return;
  if (user_options->keyspace    == true) return;
  if (user_options->stdout_flag == true) return;
  if (user_options->show        == true) return;
  if (user_options->left        == true) return;

  if (user_options->quiet == false) log_info_nn ("Started: %s", ctime (proc_start));
  if (user_options->quiet == false) log_info_nn ("Stopped: %s", ctime (proc_stop));
}

static void setup_seeding (const user_options_t *user_options, const time_t proc_start)
{
  if (user_options->rp_gen_seed_chgd == true)
  {
    srand (user_options->rp_gen_seed);
  }
  else
  {
    srand (proc_start);
  }
}

static int outer_loop (user_options_t *user_options, user_options_extra_t *user_options_extra, int myargc, char **myargv, folder_config_t *folder_config, logfile_ctx_t *logfile_ctx, tuning_db_t *tuning_db, induct_ctx_t *induct_ctx, outcheck_ctx_t *outcheck_ctx, outfile_ctx_t *outfile_ctx, rules_ctx_t *rules_ctx, opencl_ctx_t *opencl_ctx)
{
  opencl_ctx->devices_status = STATUS_INIT;

  //opencl_ctx->run_main_level1   = true;
  opencl_ctx->run_main_level2   = true;
  opencl_ctx->run_main_level3   = true;
  opencl_ctx->run_thread_level1 = true;
  opencl_ctx->run_thread_level2 = true;

  /*
   * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
   * the following algos are skipped entirely
   * still needed? there's no more bypass in benchmark mode
   * also there's no signs of special benchmark handling in the branch
   */

  /*
  if (algorithm_pos > 0)
  {
    local_free (rd);

    rd = init_restore (argc, argv, user_options);

    data.rd = rd;
  }
  */

  /**
   * setup prepare timer
   */

  time_t prepare_start;

  time (&prepare_start);

  /**
   * setup variables and buffers depending on hash_mode
   */

  hashconfig_t *hashconfig = (hashconfig_t *) mymalloc (sizeof (hashconfig_t));

  data.hashconfig = hashconfig;

  const int rc_hashconfig = hashconfig_init (hashconfig, user_options);

  if (rc_hashconfig == -1) return -1;

  /**
   * potfile
   */

  potfile_ctx_t *potfile_ctx = mymalloc (sizeof (potfile_ctx_t));

  data.potfile_ctx = potfile_ctx;

  potfile_init (potfile_ctx, folder_config->profile_dir, user_options->potfile_path, user_options->potfile_disable);

  if (user_options->show == true || user_options->left == true)
  {
    outfile_write_open (outfile_ctx);

    SUPPRESS_OUTPUT = 1;

    potfile_read_open  (potfile_ctx);

    potfile_read_parse (potfile_ctx, hashconfig);

    potfile_read_close (potfile_ctx);

    SUPPRESS_OUTPUT = 0;
  }

  /**
   * load hashes, stage 1
   */

  hashes_t *hashes = (hashes_t *) mymalloc (sizeof (hashes_t));

  data.hashes = hashes;

  const int rc_hashes_init_stage1 = hashes_init_stage1 (hashes, hashconfig, potfile_ctx, outfile_ctx, user_options, myargv[user_options_extra->optind]);

  if (rc_hashes_init_stage1 == -1) return -1;

  if ((user_options->keyspace == false) && (user_options->stdout_flag == false) && (user_options->opencl_info == false))
  {
    if (hashes->hashes_cnt == 0)
    {
      log_error ("ERROR: No hashes loaded");

      return -1;
    }
  }

  if (user_options->show == true || user_options->left == true)
  {
    outfile_write_close (outfile_ctx);

    potfile_hash_free (potfile_ctx, hashconfig);

    if (user_options->quiet == false) log_info_nn ("");

    return 0;
  }

  /**
   * Potfile removes
   */

  int potfile_remove_cracks = 0;

  if (user_options->potfile_disable == 0)
  {
    if (user_options->quiet == false) log_info_nn ("Comparing hashes with potfile entries...");

    potfile_remove_cracks = potfile_remove_parse (potfile_ctx, hashconfig, hashes);
  }

  /**
   * load hashes, stage 2, remove duplicates, build base structure
   */

  const u32 hashes_cnt_orig = hashes->hashes_cnt;

  const int rc_hashes_init_stage2 = hashes_init_stage2 (hashes, hashconfig, opencl_ctx, user_options);

  if (rc_hashes_init_stage2 == -1) return -1;

  /**
   * load hashes, stage 3, automatic Optimizers
   */

  const int rc_hashes_init_stage3 = hashes_init_stage3 (hashes, hashconfig, user_options);

  if (rc_hashes_init_stage3 == -1) return -1;

  hashes_logger (hashes, logfile_ctx);

  /**
   * bitmaps
   */

  bitmap_ctx_t *bitmap_ctx = (bitmap_ctx_t *) mymalloc (sizeof (bitmap_ctx_t));

  data.bitmap_ctx = bitmap_ctx;

  bitmap_ctx_init (bitmap_ctx, user_options, hashconfig, hashes);

  /**
   * dictstat
   */

  dictstat_ctx_t *dictstat_ctx = mymalloc (sizeof (dictstat_ctx_t));

  dictstat_init (dictstat_ctx, folder_config->profile_dir);

  if (user_options->keyspace == false)
  {
    dictstat_read (dictstat_ctx);
  }

  /**
   * loopback
   */

  loopback_ctx_t *loopback_ctx = mymalloc (sizeof (loopback_ctx_t));

  data.loopback_ctx = loopback_ctx;

  loopback_init (loopback_ctx);

  /**
   * debugfile
   */

  debugfile_ctx_t *debugfile_ctx = mymalloc (sizeof (debugfile_ctx_t));

  data.debugfile_ctx = debugfile_ctx;

  debugfile_init (debugfile_ctx, user_options->debug_mode, user_options->debug_file);

  /**
   * word len
   */

  uint pw_min = hashconfig_general_pw_min (hashconfig);
  uint pw_max = hashconfig_general_pw_max (hashconfig);

  /**
   * If we have a NOOP rule then we can process words from wordlists > length 32 for slow hashes
   */

  int has_noop = 0;

  for (uint kernel_rules_pos = 0; kernel_rules_pos < rules_ctx->kernel_rules_cnt; kernel_rules_pos++)
  {
    if (rules_ctx->kernel_rules_buf[kernel_rules_pos].cmds[0] != RULE_OP_MANGLE_NOOP) continue;
    if (rules_ctx->kernel_rules_buf[kernel_rules_pos].cmds[1] != 0)                   continue;

    has_noop = 1;
  }

  if (has_noop == 0)
  {
    switch (user_options_extra->attack_kern)
    {
      case ATTACK_KERN_STRAIGHT:  if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
                                  break;
      case ATTACK_KERN_COMBI:     if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
                                  break;
    }
  }
  else
  {
    if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
    {
      switch (user_options_extra->attack_kern)
      {
        case ATTACK_KERN_STRAIGHT:  if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
                                    break;
        case ATTACK_KERN_COMBI:     if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
                                    break;
      }
    }
    else
    {
      // in this case we can process > 32
    }
  }

  /**
   * charsets : keep them together for more easy maintainnce
   */

  cs_t mp_sys[6] = { { { 0 }, 0 } };
  cs_t mp_usr[4] = { { { 0 }, 0 } };

  mp_setup_sys (mp_sys);

  if (user_options->custom_charset_1) mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_1, 0, hashconfig, user_options);
  if (user_options->custom_charset_2) mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_2, 1, hashconfig, user_options);
  if (user_options->custom_charset_3) mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_3, 2, hashconfig, user_options);
  if (user_options->custom_charset_4) mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_4, 3, hashconfig, user_options);

  /**
   * HM devices: init
   */

  hm_attrs_t hm_adapters_adl[DEVICES_MAX];
  hm_attrs_t hm_adapters_nvapi[DEVICES_MAX];
  hm_attrs_t hm_adapters_nvml[DEVICES_MAX];
  hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX];

  memset (hm_adapters_adl,     0, sizeof (hm_adapters_adl));
  memset (hm_adapters_nvapi,   0, sizeof (hm_adapters_nvapi));
  memset (hm_adapters_nvml,    0, sizeof (hm_adapters_nvml));
  memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl));

  if (user_options->gpu_temp_disable == false)
  {
    ADL_PTR     *adl     = (ADL_PTR *)     mymalloc (sizeof (ADL_PTR));
    NVAPI_PTR   *nvapi   = (NVAPI_PTR *)   mymalloc (sizeof (NVAPI_PTR));
    NVML_PTR    *nvml    = (NVML_PTR *)    mymalloc (sizeof (NVML_PTR));
    XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));

    data.hm_adl     = NULL;
    data.hm_nvapi   = NULL;
    data.hm_nvml    = NULL;
    data.hm_xnvctrl = NULL;

    if ((opencl_ctx->need_nvml == true) && (nvml_init (nvml) == 0))
    {
      data.hm_nvml = nvml;
    }

    if (data.hm_nvml)
    {
      if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
      {
        HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };

        int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);

        int tmp_out = 0;

        for (int i = 0; i < tmp_in; i++)
        {
          hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
        }

        for (int i = 0; i < tmp_out; i++)
        {
          unsigned int speed;

          if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;

          // doesn't seem to create any advantages
          //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
          //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
        }
      }
    }

    if ((opencl_ctx->need_nvapi == true) && (nvapi_init (nvapi) == 0))
    {
      data.hm_nvapi = nvapi;
    }

    if (data.hm_nvapi)
    {
      if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
      {
        HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };

        int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);

        int tmp_out = 0;

        for (int i = 0; i < tmp_in; i++)
        {
          hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
        }
      }
    }

    if ((opencl_ctx->need_xnvctrl == true) && (xnvctrl_init (xnvctrl) == 0))
    {
      data.hm_xnvctrl = xnvctrl;
    }

    if (data.hm_xnvctrl)
    {
      if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
      {
        for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
        {
          hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

          if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;

          hm_adapters_xnvctrl[device_id].xnvctrl = device_id;

          int speed = 0;

          if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
        }
      }
    }

    if ((opencl_ctx->need_adl == true) && (adl_init (adl) == 0))
    {
      data.hm_adl = adl;
    }

    if (data.hm_adl)
    {
      if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
      {
        // total number of adapters

        int hm_adapters_num;

        if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return -1;

        // adapter info

        LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);

        if (lpAdapterInfo == NULL) return -1;

        // get a list (of ids of) valid/usable adapters

        int num_adl_adapters = 0;

        u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);

        if (num_adl_adapters > 0)
        {
          hc_thread_mutex_lock (mux_hwmon);

          // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);

          hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);

          hm_get_overdrive_version  (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
          hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);

          hc_thread_mutex_unlock (mux_hwmon);
        }

        myfree (valid_adl_device_list);
        myfree (lpAdapterInfo);
      }
    }

    if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
    {
      user_options->gpu_temp_disable = true;
    }
  }

  /**
   * OpenCL devices: allocate buffer for device specific information
   */

  ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (opencl_ctx->devices_cnt, sizeof (ADLOD6MemClockState));

  int *od_power_control_status = (int *) mycalloc (opencl_ctx->devices_cnt, sizeof (int));

  unsigned int *nvml_power_limit = (unsigned int *) mycalloc (opencl_ctx->devices_cnt, sizeof (unsigned int));

  /**
   * User-defined GPU temp handling
   */

  if (user_options->gpu_temp_disable == true)
  {
    user_options->gpu_temp_abort  = 0;
    user_options->gpu_temp_retain = 0;
  }

  /**
   * enable custom signal handler(s)
   */

  if (user_options->benchmark == false)
  {
    hc_signal (sigHandler_default);
  }
  else
  {
    hc_signal (sigHandler_benchmark);
  }

  /**
   * inform the user
   */

  if (user_options->quiet == false)
  {
    log_info ("Hashes: %u digests; %u unique digests, %u unique salts", hashes_cnt_orig, hashes->digests_cnt, hashes->salts_cnt);

    log_info ("Bitmaps: %u bits, %u entries, 0x%08x mask, %u bytes, %u/%u rotates", bitmap_ctx->bitmap_bits, bitmap_ctx->bitmap_nums, bitmap_ctx->bitmap_mask, bitmap_ctx->bitmap_size, bitmap_ctx->bitmap_shift1, bitmap_ctx->bitmap_shift2);

    if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
    {
      log_info ("Rules: %u", rules_ctx->kernel_rules_cnt);
    }

    if (hashconfig->opti_type)
    {
      log_info ("Applicable Optimizers:");

      for (uint i = 0; i < 32; i++)
      {
        const uint opti_bit = 1u << i;

        if (hashconfig->opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
      }
    }

    /**
     * Watchdog and Temperature balance
     */

    if (user_options->gpu_temp_disable == false && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
    {
      log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
    }

    if (user_options->gpu_temp_abort == 0)
    {
      log_info ("Watchdog: Temperature abort trigger disabled");
    }
    else
    {
      log_info ("Watchdog: Temperature abort trigger set to %uc", user_options->gpu_temp_abort);
    }

    if (user_options->gpu_temp_retain == 0)
    {
      log_info ("Watchdog: Temperature retain trigger disabled");
    }
    else
    {
      log_info ("Watchdog: Temperature retain trigger set to %uc", user_options->gpu_temp_retain);
    }

    if (user_options->quiet == false) log_info ("");
  }

  /**
   * HM devices: copy
   */

  if (user_options->gpu_temp_disable == false)
  {
    for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
    {
      hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

      if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;

      if (device_param->skipped) continue;

      const uint platform_devices_id = device_param->platform_devices_id;

      if (device_param->device_vendor_id == VENDOR_ID_AMD)
      {
        data.hm_device[device_id].adl               = hm_adapters_adl[platform_devices_id].adl;
        data.hm_device[device_id].nvapi             = 0;
        data.hm_device[device_id].nvml              = 0;
        data.hm_device[device_id].xnvctrl           = 0;
        data.hm_device[device_id].od_version        = hm_adapters_adl[platform_devices_id].od_version;
        data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
        data.hm_device[device_id].fan_set_supported = 0;
      }

      if (device_param->device_vendor_id == VENDOR_ID_NV)
      {
        data.hm_device[device_id].adl               = 0;
        data.hm_device[device_id].nvapi             = hm_adapters_nvapi[platform_devices_id].nvapi;
        data.hm_device[device_id].nvml              = hm_adapters_nvml[platform_devices_id].nvml;
        data.hm_device[device_id].xnvctrl           = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
        data.hm_device[device_id].od_version        = 0;
        data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
        data.hm_device[device_id].fan_set_supported = 0;
      }
    }
  }

  /**
   * powertune on user request
   */

  if (user_options->powertune_enable == true)
  {
    hc_thread_mutex_lock (mux_hwmon);

    for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
    {
      hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

      if (device_param->skipped) continue;

      if (opencl_ctx->devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
      {
        /**
         * Temporary fix:
         * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
         * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
         * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
         * Driver / ADL bug?
         */

        if (data.hm_device[device_id].od_version == 6)
        {
          int ADL_rc;

          // check powertune capabilities first, if not available then skip device

          int powertune_supported = 0;

          if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
          {
            log_error ("ERROR: Failed to get ADL PowerControl Capabilities");

            return -1;
          }

          // first backup current value, we will restore it later

          if (powertune_supported != 0)
          {
            // powercontrol settings

            ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};

            if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
            {
              ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
            }

            if (ADL_rc != ADL_OK)
            {
              log_error ("ERROR: Failed to get current ADL PowerControl settings");

              return -1;
            }

            if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
            {
              log_error ("ERROR: Failed to set new ADL PowerControl values");

              return -1;
            }

            // clocks

            memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));

            od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;

            if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
            {
              log_error ("ERROR: Failed to get ADL memory and engine clock frequency");

              return -1;
            }

            // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings

            ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};

            if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
            {
              log_error ("ERROR: Failed to get ADL device capabilities");

              return -1;
            }

            int engine_clock_max =       (int) (0.6666 * caps.sEngineClockRange.iMax);
            int memory_clock_max =       (int) (0.6250 * caps.sMemoryClockRange.iMax);

            int warning_trigger_engine = (int) (0.25   * engine_clock_max);
            int warning_trigger_memory = (int) (0.25   * memory_clock_max);

            int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
            int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;

            // warning if profile has too low max values

            if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
            {
              log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
            }

            if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
            {
              log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
            }

            ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));

            performance_state->iNumberOfPerformanceLevels = 2;

            performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
            performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
            performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
            performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;

            if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
            {
              log_info ("ERROR: Failed to set ADL performance state");

              return -1;
            }

            local_free (performance_state);
          }

          // set powertune value only

          if (powertune_supported != 0)
          {
            // powertune set
            ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};

            if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
            {
              log_error ("ERROR: Failed to get current ADL PowerControl settings");

              return -1;
            }

            if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
            {
              log_error ("ERROR: Failed to set new ADL PowerControl values");

              return -1;
            }
          }
        }
      }

      if (opencl_ctx->devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
      {
        // first backup current value, we will restore it later

        unsigned int limit;

        bool powertune_supported = false;

        if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
        {
          powertune_supported = true;
        }

        // if backup worked, activate the maximum allowed

        if (powertune_supported == true)
        {
          unsigned int minLimit;
          unsigned int maxLimit;

          if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
          {
            if (maxLimit > 0)
            {
              if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
              {
                // now we can be sure we need to reset later

                nvml_power_limit[device_id] = limit;
              }
            }
          }
        }
      }
    }

    hc_thread_mutex_unlock (mux_hwmon);
  }

  #if defined (DEBUG)
  if (user_options->benchmark == true) log_info ("Hashmode: %d", hashconfig->hash_mode);
  #endif

  if (user_options->quiet == false) log_info_nn ("Initializing device kernels and memory...");

  /*
  session_ctx_t *session_ctx = (session_ctx_t *) mymalloc (sizeof (session_ctx_t));

  data.session_ctx = session_ctx;

  session_ctx_init (session_ctx);
  */

  opencl_session_begin (opencl_ctx, hashconfig, hashes, rules_ctx, user_options, user_options_extra, folder_config, bitmap_ctx, tuning_db);

  if (user_options->quiet == false) log_info_nn ("");

  /**
   * Store initial fanspeed if gpu_temp_retain is enabled
   */

  if (user_options->gpu_temp_disable == false)
  {
    if (user_options->gpu_temp_retain)
    {
      for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
      {
        hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

        if (device_param->skipped) continue;

        hc_thread_mutex_lock (mux_hwmon);

        if (data.hm_device[device_id].fan_get_supported == true)
        {
          const int fanspeed  = hm_get_fanspeed_with_device_id  (opencl_ctx, device_id);
          const int fanpolicy = hm_get_fanpolicy_with_device_id (opencl_ctx, device_id);

          // we also set it to tell the OS we take control over the fan and it's automatic controller
          // if it was set to automatic. we do not control user-defined fanspeeds.

          if (fanpolicy == 1)
          {
            data.hm_device[device_id].fan_set_supported = true;

            int rc = -1;

            if (device_param->device_vendor_id == VENDOR_ID_AMD)
            {
              rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
            }
            else if (device_param->device_vendor_id == VENDOR_ID_NV)
            {
              #if defined (__linux__)
              rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
              #endif

              #if defined (_WIN)
              rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
              #endif
            }

            if (rc == 0)
            {
              data.hm_device[device_id].fan_set_supported = 1;
            }
            else
            {
              log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);

              data.hm_device[device_id].fan_set_supported = 0;
            }
          }
          else
          {
            data.hm_device[device_id].fan_set_supported = 0;
          }
        }

        hc_thread_mutex_unlock (mux_hwmon);
      }
    }
  }

  /**
   * In benchmark-mode, inform user which algorithm is checked
   */

  if (user_options->benchmark == true)
  {
    if (user_options->machine_readable == false)
    {
      char *hash_type = strhashtype (hashconfig->hash_mode); // not a bug

      log_info ("Hashtype: %s", hash_type);
      log_info ("");
    }
  }

  /**
   * keep track of the progress
   */

  data.words_progress_done     = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64));
  data.words_progress_rejected = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64));
  data.words_progress_restored = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64));

  /**
   * open filehandles
   */

  #if defined (_WIN)
  if (_setmode (_fileno (stdin), _O_BINARY) == -1)
  {
    log_error ("ERROR: %s: %s", "stdin", strerror (errno));

    return -1;
  }

  if (_setmode (_fileno (stdout), _O_BINARY) == -1)
  {
    log_error ("ERROR: %s: %s", "stdout", strerror (errno));

    return -1;
  }

  if (_setmode (_fileno (stderr), _O_BINARY) == -1)
  {
    log_error ("ERROR: %s: %s", "stderr", strerror (errno));

    return -1;
  }
  #endif

  /**
   * dictionary pad
   */

  wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));

  wl_data_init (wl_data, user_options, hashconfig);

  cs_t  *css_buf   = NULL;
  uint   css_cnt   = 0;
  uint   dictcnt   = 0;
  uint   maskcnt   = 1;
  char **masks     = NULL;
  char **dictfiles = NULL;

  uint   mask_from_file = 0;

  if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
  {
    if (user_options_extra->wordlist_mode == WL_MODE_FILE)
    {
      int wls_left = myargc - (user_options_extra->optind + 1);

      for (int i = 0; i < wls_left; i++)
      {
        char *l0_filename = myargv[user_options_extra->optind + 1 + i];

        struct stat l0_stat;

        if (stat (l0_filename, &l0_stat) == -1)
        {
          log_error ("ERROR: %s: %s", l0_filename, strerror (errno));

          return -1;
        }

        uint is_dir = S_ISDIR (l0_stat.st_mode);

        if (is_dir == 0)
        {
          dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));

          dictcnt++;

          dictfiles[dictcnt - 1] = l0_filename;
        }
        else
        {
          // do not allow --keyspace w/ a directory

          if (user_options->keyspace == true)
          {
            log_error ("ERROR: Keyspace parameter is not allowed together with a directory");

            return -1;
          }

          char **dictionary_files = NULL;

          dictionary_files = scan_directory (l0_filename);

          if (dictionary_files != NULL)
          {
            qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);

            for (int d = 0; dictionary_files[d] != NULL; d++)
            {
              char *l1_filename = dictionary_files[d];

              struct stat l1_stat;

              if (stat (l1_filename, &l1_stat) == -1)
              {
                log_error ("ERROR: %s: %s", l1_filename, strerror (errno));

                return -1;
              }

              if (S_ISREG (l1_stat.st_mode))
              {
                dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));

                dictcnt++;

                dictfiles[dictcnt - 1] = mystrdup (l1_filename);
              }
            }
          }

          local_free (dictionary_files);
        }
      }

      if (dictcnt < 1)
      {
        log_error ("ERROR: No usable dictionary file found.");

        return -1;
      }
    }
    else if (user_options_extra->wordlist_mode == WL_MODE_STDIN)
    {
      dictcnt = 1;
    }
  }
  else if (user_options->attack_mode == ATTACK_MODE_COMBI)
  {
    // display

    char *dictfile1 = myargv[user_options_extra->optind + 1 + 0];
    char *dictfile2 = myargv[user_options_extra->optind + 1 + 1];

    // find the bigger dictionary and use as base

    FILE *fp1 = NULL;
    FILE *fp2 = NULL;

    struct stat tmp_stat;

    if ((fp1 = fopen (dictfile1, "rb")) == NULL)
    {
      log_error ("ERROR: %s: %s", dictfile1, strerror (errno));

      return -1;
    }

    if (stat (dictfile1, &tmp_stat) == -1)
    {
      log_error ("ERROR: %s: %s", dictfile1, strerror (errno));

      fclose (fp1);

      return -1;
    }

    if (S_ISDIR (tmp_stat.st_mode))
    {
      log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));

      fclose (fp1);

      return -1;
    }

    if ((fp2 = fopen (dictfile2, "rb")) == NULL)
    {
      log_error ("ERROR: %s: %s", dictfile2, strerror (errno));

      fclose (fp1);

      return -1;
    }

    if (stat (dictfile2, &tmp_stat) == -1)
    {
      log_error ("ERROR: %s: %s", dictfile2, strerror (errno));

      fclose (fp1);
      fclose (fp2);

      return -1;
    }

    if (S_ISDIR (tmp_stat.st_mode))
    {
      log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));

      fclose (fp1);
      fclose (fp2);

      return -1;
    }

    data.combs_cnt = 1;

    const u64 words1_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fp1, dictfile1, dictstat_ctx);

    if (words1_cnt == 0)
    {
      log_error ("ERROR: %s: empty file", dictfile1);

      fclose (fp1);
      fclose (fp2);

      return -1;
    }

    data.combs_cnt = 1;

    const u64 words2_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fp2, dictfile2, dictstat_ctx);

    if (words2_cnt == 0)
    {
      log_error ("ERROR: %s: empty file", dictfile2);

      fclose (fp1);
      fclose (fp2);

      return -1;
    }

    fclose (fp1);
    fclose (fp2);

    data.dictfile  = dictfile1;
    data.dictfile2 = dictfile2;

    if (words1_cnt >= words2_cnt)
    {
      data.combs_cnt  = words2_cnt;
      data.combs_mode = COMBINATOR_MODE_BASE_LEFT;

      dictfiles = &data.dictfile;

      dictcnt = 1;
    }
    else
    {
      data.combs_cnt  = words1_cnt;
      data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;

      dictfiles = &data.dictfile2;

      dictcnt = 1;

      // we also have to switch wordlist related rules!

      char *tmpc = user_options->rule_buf_l;

      user_options->rule_buf_l = user_options->rule_buf_r;
      user_options->rule_buf_r = tmpc;

      int   tmpi = user_options_extra->rule_len_l;

      user_options_extra->rule_len_l = user_options_extra->rule_len_r;
      user_options_extra->rule_len_r = tmpi;
    }
  }
  else if (user_options->attack_mode == ATTACK_MODE_BF)
  {
    char *mask = NULL;

    maskcnt = 0;

    if (user_options->benchmark == false)
    {
      mask = myargv[user_options_extra->optind + 1];

      masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));

      if ((user_options_extra->optind + 2) <= myargc)
      {
        struct stat file_stat;

        if (stat (mask, &file_stat) == -1)
        {
          maskcnt = 1;

          masks[maskcnt - 1] = mystrdup (mask);
        }
        else
        {
          int wls_left = myargc - (user_options_extra->optind + 1);

          uint masks_avail = INCR_MASKS;

          for (int i = 0; i < wls_left; i++)
          {
            if (i != 0)
            {
              mask = myargv[user_options_extra->optind + 1 + i];

              if (stat (mask, &file_stat) == -1)
              {
                log_error ("ERROR: %s: %s", mask, strerror (errno));

                return -1;
              }
            }

            uint is_file = S_ISREG (file_stat.st_mode);

            if (is_file == 1)
            {
              FILE *mask_fp;

              if ((mask_fp = fopen (mask, "r")) == NULL)
              {
                log_error ("ERROR: %s: %s", mask, strerror (errno));

                return -1;
              }

              char *line_buf = (char *) mymalloc (HCBUFSIZ_LARGE);

              while (!feof (mask_fp))
              {
                memset (line_buf, 0, HCBUFSIZ_LARGE);

                int line_len = fgetl (mask_fp, line_buf);

                if (line_len == 0) continue;

                if (line_buf[0] == '#') continue;

                if (masks_avail == maskcnt)
                {
                  masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));

                  masks_avail += INCR_MASKS;
                }

                masks[maskcnt] = mystrdup (line_buf);

                maskcnt++;
              }

              myfree (line_buf);

              fclose (mask_fp);
            }
            else
            {
              log_error ("ERROR: %s: unsupported file-type", mask);

              return -1;
            }
          }

          mask_from_file = 1;
        }
      }
      else
      {
        user_options->custom_charset_1 = (char *) "?l?d?u";
        user_options->custom_charset_2 = (char *) "?l?d";
        user_options->custom_charset_3 = (char *) "?l?d*!$@_";

        mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_1, 0, hashconfig, user_options);
        mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_2, 1, hashconfig, user_options);
        mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_3, 2, hashconfig, user_options);

        maskcnt = 1;

        masks[maskcnt - 1] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");

        user_options->increment = true;
      }
    }
    else
    {
      /**
       * generate full masks and charsets
       */

      mask = hashconfig_benchmark_mask (hashconfig);

      pw_min = mp_get_length (mask);
      pw_max = pw_min;

      masks = (char **) mymalloc (sizeof (char *));

      maskcnt = 1;

      masks[maskcnt - 1] = mystrdup (mask);

      user_options->increment = true;
    }

    dictfiles = (char **) mycalloc (pw_max, sizeof (char *));

    if (user_options->increment == true)
    {
      if (user_options->increment_min > pw_min) pw_min = user_options->increment_min;
      if (user_options->increment_max < pw_max) pw_max = user_options->increment_max;
    }
  }
  else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
  {
    data.combs_mode = COMBINATOR_MODE_BASE_LEFT;

    // display

    char *mask = myargv[myargc - 1];

    maskcnt = 0;

    masks = (char **) mymalloc (1 * sizeof (char *));

    // mod

    struct stat file_stat;

    if (stat (mask, &file_stat) == -1)
    {
      maskcnt = 1;

      masks[maskcnt - 1] = mystrdup (mask);
    }
    else
    {
      uint is_file = S_ISREG (file_stat.st_mode);

      if (is_file == 1)
      {
        FILE *mask_fp;

        if ((mask_fp = fopen (mask, "r")) == NULL)
        {
          log_error ("ERROR: %s: %s", mask, strerror (errno));

          return -1;
        }

        char *line_buf = (char *) mymalloc (HCBUFSIZ_LARGE);

        uint masks_avail = 1;

        while (!feof (mask_fp))
        {
          memset (line_buf, 0, HCBUFSIZ_LARGE);

          int line_len = fgetl (mask_fp, line_buf);

          if (line_len == 0) continue;

          if (line_buf[0] == '#') continue;

          if (masks_avail == maskcnt)
          {
            masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));

            masks_avail += INCR_MASKS;
          }

          masks[maskcnt] = mystrdup (line_buf);

          maskcnt++;
        }

        myfree (line_buf);

        fclose (mask_fp);

        mask_from_file = 1;
      }
      else
      {
        maskcnt = 1;

        masks[maskcnt - 1] = mystrdup (mask);
      }
    }

    // base

    int wls_left = myargc - (user_options_extra->optind + 2);

    for (int i = 0; i < wls_left; i++)
    {
      char *filename = myargv[user_options_extra->optind + 1 + i];

      struct stat file_stat;

      if (stat (filename, &file_stat) == -1)
      {
        log_error ("ERROR: %s: %s", filename, strerror (errno));

        return -1;
      }

      uint is_dir = S_ISDIR (file_stat.st_mode);

      if (is_dir == 0)
      {
        dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));

        dictcnt++;

        dictfiles[dictcnt - 1] = filename;
      }
      else
      {
        // do not allow --keyspace w/ a directory

        if (user_options->keyspace == true)
        {
          log_error ("ERROR: Keyspace parameter is not allowed together with a directory");

          return -1;
        }

        char **dictionary_files = NULL;

        dictionary_files = scan_directory (filename);

        if (dictionary_files != NULL)
        {
          qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);

          for (int d = 0; dictionary_files[d] != NULL; d++)
          {
            char *l1_filename = dictionary_files[d];

            struct stat l1_stat;

            if (stat (l1_filename, &l1_stat) == -1)
            {
              log_error ("ERROR: %s: %s", l1_filename, strerror (errno));

              return -1;
            }

            if (S_ISREG (l1_stat.st_mode))
            {
              dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));

              dictcnt++;

              dictfiles[dictcnt - 1] = mystrdup (l1_filename);
            }
          }
        }

        local_free (dictionary_files);
      }
    }

    if (dictcnt < 1)
    {
      log_error ("ERROR: No usable dictionary file found.");

      return -1;
    }

    if (user_options->increment == true)
    {
      maskcnt = 0;

      uint mask_min = user_options->increment_min; // we can't reject smaller masks here
      uint mask_max = (user_options->increment_max < pw_max) ? user_options->increment_max : pw_max;

      for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
      {
        char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur, user_options);

        if (cur_mask == NULL) break;

        masks[maskcnt] = cur_mask;

        maskcnt++;

        masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
      }
    }
  }
  else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
  {
    data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;

    // display

    char *mask = myargv[user_options_extra->optind + 1 + 0];

    maskcnt = 0;

    masks = (char **) mymalloc (1 * sizeof (char *));

    // mod

    struct stat file_stat;

    if (stat (mask, &file_stat) == -1)
    {
      maskcnt = 1;

      masks[maskcnt - 1] = mystrdup (mask);
    }
    else
    {
      uint is_file = S_ISREG (file_stat.st_mode);

      if (is_file == 1)
      {
        FILE *mask_fp;

        if ((mask_fp = fopen (mask, "r")) == NULL)
        {
          log_error ("ERROR: %s: %s", mask, strerror (errno));

          return -1;
        }

        char *line_buf = (char *) mymalloc (HCBUFSIZ_LARGE);

        uint masks_avail = 1;

        while (!feof (mask_fp))
        {
          memset (line_buf, 0, HCBUFSIZ_LARGE);

          int line_len = fgetl (mask_fp, line_buf);

          if (line_len == 0) continue;

          if (line_buf[0] == '#') continue;

          if (masks_avail == maskcnt)
          {
            masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));

            masks_avail += INCR_MASKS;
          }

          masks[maskcnt] = mystrdup (line_buf);

          maskcnt++;
        }

        myfree (line_buf);

        fclose (mask_fp);

        mask_from_file = 1;
      }
      else
      {
        maskcnt = 1;

        masks[maskcnt - 1] = mystrdup (mask);
      }
    }

    // base

    int wls_left = myargc - (user_options_extra->optind + 2);

    for (int i = 0; i < wls_left; i++)
    {
      char *filename = myargv[user_options_extra->optind + 2 + i];

      struct stat file_stat;

      if (stat (filename, &file_stat) == -1)
      {
        log_error ("ERROR: %s: %s", filename, strerror (errno));

        return -1;
      }

      uint is_dir = S_ISDIR (file_stat.st_mode);

      if (is_dir == 0)
      {
        dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));

        dictcnt++;

        dictfiles[dictcnt - 1] = filename;
      }
      else
      {
        // do not allow --keyspace w/ a directory

        if (user_options->keyspace == true)
        {
          log_error ("ERROR: Keyspace parameter is not allowed together with a directory");

          return -1;
        }

        char **dictionary_files = NULL;

        dictionary_files = scan_directory (filename);

        if (dictionary_files != NULL)
        {
          qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);

          for (int d = 0; dictionary_files[d] != NULL; d++)
          {
            char *l1_filename = dictionary_files[d];

            struct stat l1_stat;

            if (stat (l1_filename, &l1_stat) == -1)
            {
              log_error ("ERROR: %s: %s", l1_filename, strerror (errno));

              return -1;
            }

            if (S_ISREG (l1_stat.st_mode))
            {
              dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));

              dictcnt++;

              dictfiles[dictcnt - 1] = mystrdup (l1_filename);
            }
          }
        }

        local_free (dictionary_files);
      }
    }

    if (dictcnt < 1)
    {
      log_error ("ERROR: No usable dictionary file found.");

      return -1;
    }

    if (user_options->increment == true)
    {
      maskcnt = 0;

      uint mask_min = user_options->increment_min; // we can't reject smaller masks here
      uint mask_max = (user_options->increment_max < pw_max) ? user_options->increment_max : pw_max;

      for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
      {
        char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur, user_options);

        if (cur_mask == NULL) break;

        masks[maskcnt] = cur_mask;

        maskcnt++;

        masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
      }
    }
  }

  data.pw_min = pw_min;
  data.pw_max = pw_max;

  /**
   * weak hash check
   */

  potfile_write_open (potfile_ctx);

  /**
   * weak hash check
   */

  if (user_options->weak_hash_threshold >= hashes->salts_cnt)
  {
    hc_device_param_t *device_param = NULL;

    for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
    {
      device_param = &opencl_ctx->devices_param[device_id];

      if (device_param->skipped) continue;

      break;
    }

    if (user_options->quiet == false) log_info_nn ("Checking for weak hashes...");

    for (uint salt_pos = 0; salt_pos < hashes->salts_cnt; salt_pos++)
    {
      weak_hash_check (opencl_ctx, device_param, user_options, user_options_extra, rules_ctx, hashconfig, hashes, salt_pos);
    }
  }

  /**
   * status and monitor threads
   */

  uint inner_threads_cnt = 0;

  hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));

  data.shutdown_inner = 0;

  /**
    * Outfile remove
    */

  if (user_options->keyspace == false && user_options->benchmark == false && user_options->stdout_flag == false)
  {
    hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);

    inner_threads_cnt++;

    if (outcheck_ctx->enabled == true)
    {
      hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);

      inner_threads_cnt++;
    }
  }

  /**
   * main loop
   */

  if (user_options->quiet == false)
  {
    if (potfile_remove_cracks > 0)
    {
      if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in potfile\n");
      else                            log_info ("INFO: Removed %d hashes found in potfile\n", potfile_remove_cracks);
    }
  }

  hcstat_table_t *root_table_buf   = NULL;
  hcstat_table_t *markov_table_buf = NULL;

  uint initial_restore_done = 0;

  data.maskcnt = maskcnt;

  restore_data_t *rd = data.rd;

  for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
  {
    //opencl_ctx->run_main_level1   = true;
    //opencl_ctx->run_main_level2   = true;
    opencl_ctx->run_main_level3   = true;
    opencl_ctx->run_thread_level1 = true;
    opencl_ctx->run_thread_level2 = true;

    if (maskpos > rd->maskpos)
    {
      rd->dictpos = 0;
    }

    rd->maskpos  = maskpos;
    data.maskpos = maskpos;

    if (user_options->attack_mode == ATTACK_MODE_HYBRID1 || user_options->attack_mode == ATTACK_MODE_HYBRID2 || user_options->attack_mode == ATTACK_MODE_BF)
    {
      char *mask = masks[maskpos];

      if (mask_from_file == true)
      {
        if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"

        char *str_ptr;
        uint  str_pos;

        uint mask_offset = 0;

        uint separator_cnt;

        for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
        {
          str_ptr = strstr (mask + mask_offset, ",");

          if (str_ptr == NULL) break;

          str_pos = str_ptr - mask;

          // escaped separator, i.e. "\,"

          if (str_pos > 0)
          {
            if (mask[str_pos - 1] == '\\')
            {
              separator_cnt --;

              mask_offset = str_pos + 1;

              continue;
            }
          }

          // reset the offset

          mask_offset = 0;

          mask[str_pos] = '\0';

          switch (separator_cnt)
          {
            case 0:
              mp_reset_usr (mp_usr, 0);

              user_options->custom_charset_1 = mask;
              mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_1, 0, hashconfig, user_options);
              break;

            case 1:
              mp_reset_usr (mp_usr, 1);

              user_options->custom_charset_2 = mask;
              mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_2, 1, hashconfig, user_options);
              break;

            case 2:
              mp_reset_usr (mp_usr, 2);

              user_options->custom_charset_3 = mask;
              mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_3, 2, hashconfig, user_options);
              break;

            case 3:
              mp_reset_usr (mp_usr, 3);

              user_options->custom_charset_4 = mask;
              mp_setup_usr (mp_sys, mp_usr, user_options->custom_charset_4, 3, hashconfig, user_options);
              break;
          }

          mask = mask + str_pos + 1;
        }

        /**
         * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\")
         * it would be interpreted as a custom charset definition.
         *
         * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
         * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by ","
         */

        uint mask_len_cur = strlen (mask);

        uint mask_out_pos = 0;
        char mask_prev = 0;

        for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
        {
          if (mask[mask_iter] == ',')
          {
            if (mask_prev == '\\')
            {
              mask_out_pos -= 1; // this means: skip the previous "\"
            }
          }

          mask_prev = mask[mask_iter];

          mask[mask_out_pos] = mask[mask_iter];
        }

        mask[mask_out_pos] = '\0';
      }

      if ((user_options->attack_mode == ATTACK_MODE_HYBRID1) || (user_options->attack_mode == ATTACK_MODE_HYBRID2))
      {
        if (maskpos > 0)
        {
          local_free (css_buf);
          local_free (data.root_css_buf);
          local_free (data.markov_css_buf);

          local_free (masks[maskpos - 1]);
        }

        css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt, hashconfig, user_options);

        data.mask = mask;
        data.css_cnt = css_cnt;
        data.css_buf = css_buf;

        uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };

        mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);

        if (root_table_buf   == NULL) root_table_buf   = (hcstat_table_t *) mycalloc (SP_ROOT_CNT,   sizeof (hcstat_table_t));
        if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));

        sp_setup_tbl (folder_config->shared_dir, user_options->markov_hcstat, user_options->markov_disable, user_options->markov_classic, root_table_buf, markov_table_buf);

        cs_t *root_css_buf   = (cs_t *) mycalloc (SP_PW_MAX,           sizeof (cs_t));
        cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));

        data.root_css_buf   = root_css_buf;
        data.markov_css_buf = markov_css_buf;

        sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, user_options->markov_threshold, uniq_tbls);

        data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);

        local_free (root_table_buf);
        local_free (markov_table_buf);

        // args

        for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
        {
          hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

          if (device_param->skipped) continue;

          device_param->kernel_params_mp[0] = &device_param->d_combs;
          device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
          device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;

          device_param->kernel_params_mp_buf64[3] = 0;
          device_param->kernel_params_mp_buf32[4] = css_cnt;
          device_param->kernel_params_mp_buf32[5] = 0;
          device_param->kernel_params_mp_buf32[6] = 0;
          device_param->kernel_params_mp_buf32[7] = 0;

          if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
          {
            if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01)     device_param->kernel_params_mp_buf32[5] = full01;
            if (hashconfig->opts_type & OPTS_TYPE_PT_ADD80)     device_param->kernel_params_mp_buf32[5] = full80;
            if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
            if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
          }
          else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
          {
            device_param->kernel_params_mp_buf32[5] = 0;
            device_param->kernel_params_mp_buf32[6] = 0;
            device_param->kernel_params_mp_buf32[7] = 0;
          }

          cl_int CL_err = CL_SUCCESS;

          for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_mem),   (void *) device_param->kernel_params_mp[i]);
          for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
          for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_uint),  (void *) device_param->kernel_params_mp[i]);

          if (CL_err != CL_SUCCESS)
          {
            log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));

            return -1;
          }

          CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_root_css_buf,   CL_TRUE, 0, device_param->size_root_css,   root_css_buf,   0, NULL, NULL);
          CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);

          if (CL_err != CL_SUCCESS)
          {
            log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));

            return -1;
          }
        }
      }
      else if (user_options->attack_mode == ATTACK_MODE_BF)
      {
        dictcnt = 0;  // number of "sub-masks", i.e. when using incremental mode

        if (user_options->increment == true)
        {
          for (uint i = 0; i < dictcnt; i++)
          {
            local_free (dictfiles[i]);
          }

          for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
          {
            char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len, user_options);

            if (l1_filename == NULL) break;

            dictcnt++;

            dictfiles[dictcnt - 1] = l1_filename;
          }
        }
        else
        {
          dictcnt++;

          dictfiles[dictcnt - 1] = mask;
        }

        if (dictcnt == 0)
        {
          log_error ("ERROR: Mask is too small");

          return -1;
        }
      }
    }

    /**
     * update induction directory scan
     */

    induct_ctx_scan (induct_ctx);

    /**
     * prevent the user from using --skip/--limit together w/ maskfile and or dictfile
     */

    if (user_options->skip != 0 || user_options->limit != 0)
    {
      if ((maskcnt > 1) || (dictcnt > 1))
      {
        log_error ("ERROR: --skip/--limit are not supported with --increment or mask files");

        return -1;
      }
    }

    /**
     * prevent the user from using --keyspace together w/ maskfile and or dictfile
     */

    if (user_options->keyspace == true)
    {
      if ((maskcnt > 1) || (dictcnt > 1))
      {
        log_error ("ERROR: --keyspace is not supported with --increment or mask files");

        return -1;
      }
    }

    for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
    {
      if (opencl_ctx->run_main_level3 == false) break;

      //opencl_ctx->run_main_level1   = true;
      //opencl_ctx->run_main_level2   = true;
      //opencl_ctx->run_main_level3   = true;
      opencl_ctx->run_thread_level1 = true;
      opencl_ctx->run_thread_level2 = true;

      rd->dictpos = dictpos;

      logfile_generate_subid (logfile_ctx);

      logfile_sub_msg ("START");

      memset (data.words_progress_done,     0, hashes->salts_cnt * sizeof (u64));
      memset (data.words_progress_rejected, 0, hashes->salts_cnt * sizeof (u64));
      memset (data.words_progress_restored, 0, hashes->salts_cnt * sizeof (u64));

      memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));

      data.cpt_pos = 0;

      data.cpt_start = time (NULL);

      data.cpt_total = 0;

      if (user_options->restore == false)
      {
        rd->words_cur = user_options->skip;

        user_options->skip = 0;
      }

      data.ms_paused = 0;

      data.kernel_power_final = 0;

      data.words_cur = rd->words_cur;

      for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
      {
        hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

        if (device_param->skipped) continue;

        device_param->speed_pos = 0;

        memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
        memset (device_param->speed_ms,  0, SPEED_CACHE * sizeof (double));

        device_param->exec_pos = 0;

        memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));

        device_param->outerloop_pos  = 0;
        device_param->outerloop_left = 0;
        device_param->innerloop_pos  = 0;
        device_param->innerloop_left = 0;

        // some more resets:

        if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);

        device_param->pws_cnt = 0;

        device_param->words_off  = 0;
        device_param->words_done = 0;
      }

      // figure out some workload

      if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
      {
        if (user_options_extra->wordlist_mode == WL_MODE_FILE)
        {
          char *dictfile = NULL;

          if (induct_ctx->induction_dictionaries_cnt)
          {
            dictfile = induct_ctx->induction_dictionaries[0];
          }
          else
          {
            dictfile = dictfiles[dictpos];
          }

          data.dictfile = dictfile;

          logfile_sub_string (dictfile);

          for (uint i = 0; i < user_options->rp_files_cnt; i++)
          {
            logfile_sub_var_string ("rulefile", user_options->rp_files[i]);
          }

          FILE *fd2 = fopen (dictfile, "rb");

          if (fd2 == NULL)
          {
            log_error ("ERROR: %s: %s", dictfile, strerror (errno));

            return -1;
          }

          data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx);

          fclose (fd2);

          if (data.words_cnt == 0)
          {
            logfile_sub_msg ("STOP");

            continue;
          }
        }
      }
      else if (user_options->attack_mode == ATTACK_MODE_COMBI)
      {
        char *dictfile  = data.dictfile;
        char *dictfile2 = data.dictfile2;

        logfile_sub_string (dictfile);
        logfile_sub_string (dictfile2);

        if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
        {
          FILE *fd2 = fopen (dictfile, "rb");

          if (fd2 == NULL)
          {
            log_error ("ERROR: %s: %s", dictfile, strerror (errno));

            return -1;
          }

          data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx);

          fclose (fd2);
        }
        else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
        {
          FILE *fd2 = fopen (dictfile2, "rb");

          if (fd2 == NULL)
          {
            log_error ("ERROR: %s: %s", dictfile2, strerror (errno));

            return -1;
          }

          data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile2, dictstat_ctx);

          fclose (fd2);
        }

        if (data.words_cnt == 0)
        {
          logfile_sub_msg ("STOP");

          continue;
        }
      }
      else if ((user_options->attack_mode == ATTACK_MODE_HYBRID1) || (user_options->attack_mode == ATTACK_MODE_HYBRID2))
      {
        char *dictfile = NULL;

        if (induct_ctx->induction_dictionaries_cnt)
        {
          dictfile = induct_ctx->induction_dictionaries[0];
        }
        else
        {
          dictfile = dictfiles[dictpos];
        }

        data.dictfile = dictfile;

        char *mask = data.mask;

        logfile_sub_string (dictfile);
        logfile_sub_string (mask);

        FILE *fd2 = fopen (dictfile, "rb");

        if (fd2 == NULL)
        {
          log_error ("ERROR: %s: %s", dictfile, strerror (errno));

          return -1;
        }

        data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx);

        fclose (fd2);

        if (data.words_cnt == 0)
        {
          logfile_sub_msg ("STOP");

          continue;
        }
      }
      else if (user_options->attack_mode == ATTACK_MODE_BF)
      {
        local_free (css_buf);
        local_free (data.root_css_buf);
        local_free (data.markov_css_buf);

        char *mask = dictfiles[dictpos];

        logfile_sub_string (mask);

        // base

        css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt, hashconfig, user_options);

        if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE)
        {
          uint css_cnt_unicode = css_cnt * 2;

          cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));

          for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
          {
            memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));

            css_buf_unicode[j + 1].cs_buf[0] = 0;
            css_buf_unicode[j + 1].cs_len    = 1;
          }

          free (css_buf);

          css_buf = css_buf_unicode;
          css_cnt = css_cnt_unicode;
        }

        // check if mask is not too large or too small for pw_min/pw_max  (*2 if unicode)

        uint mask_min = pw_min;
        uint mask_max = pw_max;

        if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE)
        {
          mask_min *= 2;
          mask_max *= 2;
        }

        if ((css_cnt < mask_min) || (css_cnt > mask_max))
        {
          if (css_cnt < mask_min)
          {
            log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
          }

          if (css_cnt > mask_max)
          {
            log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
          }

          // skip to next mask

          logfile_sub_msg ("STOP");

          continue;
        }

        uint save_css_cnt = css_cnt;

        if (hashconfig->opti_type & OPTI_TYPE_SINGLE_HASH)
        {
          if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT)
          {
            uint  salt_len = (uint)   hashes->salts_buf[0].salt_len;
            char *salt_buf = (char *) hashes->salts_buf[0].salt_buf;

            uint css_cnt_salt = css_cnt + salt_len;

            cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));

            memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));

            for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
            {
              css_buf_salt[j].cs_buf[0] = salt_buf[i];
              css_buf_salt[j].cs_len    = 1;
            }

            free (css_buf);

            css_buf = css_buf_salt;
            css_cnt = css_cnt_salt;
          }
        }

        data.mask = mask;
        data.css_cnt = css_cnt;
        data.css_buf = css_buf;

        if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);

        uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };

        mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);

        if (root_table_buf   == NULL) root_table_buf   = (hcstat_table_t *) mycalloc (SP_ROOT_CNT,   sizeof (hcstat_table_t));
        if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));

        sp_setup_tbl (folder_config->shared_dir, user_options->markov_hcstat, user_options->markov_disable, user_options->markov_classic, root_table_buf, markov_table_buf);

        cs_t *root_css_buf   = (cs_t *) mycalloc (SP_PW_MAX,           sizeof (cs_t));
        cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));

        data.root_css_buf   = root_css_buf;
        data.markov_css_buf = markov_css_buf;

        sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, user_options->markov_threshold, uniq_tbls);

        data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);

        local_free (root_table_buf);
        local_free (markov_table_buf);

        // copy + args

        uint css_cnt_l = css_cnt;
        uint css_cnt_r;

        if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
        {
          if (save_css_cnt < 6)
          {
            css_cnt_r = 1;
          }
          else if (save_css_cnt == 6)
          {
            css_cnt_r = 2;
          }
          else
          {
            if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE)
            {
              if (save_css_cnt == 8 || save_css_cnt == 10)
              {
                css_cnt_r = 2;
              }
              else
              {
                css_cnt_r = 4;
              }
            }
            else
            {
              if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
              {
                css_cnt_r = 3;
              }
              else
              {
                css_cnt_r = 4;
              }
            }
          }
        }
        else
        {
          css_cnt_r = 1;

          /* unfinished code?
          int sum = css_buf[css_cnt_r - 1].cs_len;

          for (uint i = 1; i < 4 && i < css_cnt; i++)
          {
            if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes

            css_cnt_r++;

            sum *= css_buf[css_cnt_r - 1].cs_len;
          }
          */
        }

        css_cnt_l -= css_cnt_r;

        data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);

        for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
        {
          hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

          if (device_param->skipped) continue;

          device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
          device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
          device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;

          device_param->kernel_params_mp_l_buf64[3] = 0;
          device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
          device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
          device_param->kernel_params_mp_l_buf32[6] = 0;
          device_param->kernel_params_mp_l_buf32[7] = 0;
          device_param->kernel_params_mp_l_buf32[8] = 0;

          if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01)     device_param->kernel_params_mp_l_buf32[6] = full01;
          if (hashconfig->opts_type & OPTS_TYPE_PT_ADD80)     device_param->kernel_params_mp_l_buf32[6] = full80;
          if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
          if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;

          device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
          device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
          device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;

          device_param->kernel_params_mp_r_buf64[3] = 0;
          device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
          device_param->kernel_params_mp_r_buf32[5] = 0;
          device_param->kernel_params_mp_r_buf32[6] = 0;
          device_param->kernel_params_mp_r_buf32[7] = 0;

          cl_int CL_err = CL_SUCCESS;

          for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_mem),   (void *) device_param->kernel_params_mp_l[i]);
          for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
          for (uint i = 4; i < 9; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_uint),  (void *) device_param->kernel_params_mp_l[i]);

          for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_mem),   (void *) device_param->kernel_params_mp_r[i]);
          for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
          for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_uint),  (void *) device_param->kernel_params_mp_r[i]);

          if (CL_err != CL_SUCCESS)
          {
            log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));

            return -1;
          }

          CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_root_css_buf,   CL_TRUE, 0, device_param->size_root_css,   root_css_buf,   0, NULL, NULL);
          CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);

          if (CL_err != CL_SUCCESS)
          {
            log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));

            return -1;
          }
        }
      }

      u64 words_base = data.words_cnt;

      if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT)
      {
        if (rules_ctx->kernel_rules_cnt)
        {
          words_base /= rules_ctx->kernel_rules_cnt;
        }
      }
      else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI)
      {
        if (data.combs_cnt)
        {
          words_base /= data.combs_cnt;
        }
      }
      else if (user_options_extra->attack_kern == ATTACK_KERN_BF)
      {
        if (data.bfs_cnt)
        {
          words_base /= data.bfs_cnt;
        }
      }

      data.words_base = words_base;

      if (user_options->keyspace == true)
      {
        log_info ("%" PRIu64 "", words_base);

        return 0;
      }

      if (data.words_cur > data.words_base)
      {
        log_error ("ERROR: Restore value greater keyspace");

        return -1;
      }

      if (data.words_cur)
      {
        if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT)
        {
          for (uint i = 0; i < hashes->salts_cnt; i++)
          {
            data.words_progress_restored[i] = data.words_cur * rules_ctx->kernel_rules_cnt;
          }
        }
        else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI)
        {
          for (uint i = 0; i < hashes->salts_cnt; i++)
          {
            data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
          }
        }
        else if (user_options_extra->attack_kern == ATTACK_KERN_BF)
        {
          for (uint i = 0; i < hashes->salts_cnt; i++)
          {
            data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
          }
        }
      }

      /*
       * Update dictionary statistic
       */

      if (user_options->keyspace == false)
      {
        dictstat_write (dictstat_ctx);
      }

      /**
       * Update loopback file
       */

      if (user_options->loopback == true)
      {
        loopback_write_open (loopback_ctx, induct_ctx->root_directory);
      }

      /**
       * some algorithms have a maximum kernel-loops count
       */

      for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
      {
        hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

        if (device_param->skipped) continue;

        if (device_param->kernel_loops_min < device_param->kernel_loops_max)
        {
          u32 innerloop_cnt = 0;

          if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
          {
            if      (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT)  innerloop_cnt = rules_ctx->kernel_rules_cnt;
            else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI)     innerloop_cnt = data.combs_cnt;
            else if (user_options_extra->attack_kern == ATTACK_KERN_BF)        innerloop_cnt = data.bfs_cnt;
          }
          else
          {
            innerloop_cnt = hashes->salts_buf[0].salt_iter;
          }

          if ((innerloop_cnt >= device_param->kernel_loops_min) &&
              (innerloop_cnt <= device_param->kernel_loops_max))
          {
            device_param->kernel_loops_max = innerloop_cnt;
          }
        }
      }

      /**
       * create autotune threads
       */

      hc_thread_t *c_threads = (hc_thread_t *) mycalloc (opencl_ctx->devices_cnt, sizeof (hc_thread_t));

      opencl_ctx->devices_status = STATUS_AUTOTUNE;

      for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
      {
        hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

        hc_thread_create (c_threads[device_id], thread_autotune, device_param);
      }

      hc_thread_wait (opencl_ctx->devices_cnt, c_threads);

      /*
       * Inform user about possible slow speeds
       */

      uint hardware_power_all = 0;

      uint kernel_power_all = 0;

      for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
      {
        hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

        hardware_power_all += device_param->hardware_power;

        kernel_power_all += device_param->kernel_power;
      }

      data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices

      data.kernel_power_all = kernel_power_all;

      if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK))
      {
        if (data.words_base < kernel_power_all)
        {
          if (user_options->quiet == false)
          {
            clear_prompt ();

            log_info ("ATTENTION!");
            log_info ("  The wordlist or mask you are using is too small.");
            log_info ("  Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
            log_info ("  The cracking speed will drop.");
            log_info ("  Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
            log_info ("");
          }
        }
      }

      /**
       * create cracker threads
       */

      opencl_ctx->devices_status = STATUS_RUNNING;

      if (initial_restore_done == 0)
      {
        if (user_options->restore_disable == false) cycle_restore (opencl_ctx);

        initial_restore_done = 1;
      }

      hc_timer_set (&data.timer_running);

      if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK))
      {
        if ((user_options->quiet == false) && (user_options->status == false) && (user_options->benchmark == false))
        {
          if (user_options->quiet == false) send_prompt ();
        }
      }
      else if (user_options_extra->wordlist_mode == WL_MODE_STDIN)
      {
        if (user_options->quiet == false) log_info ("Starting attack in stdin mode...");
        if (user_options->quiet == false) log_info ("");
      }

      time_t runtime_start;

      time (&runtime_start);

      data.runtime_start = runtime_start;

      data.prepare_time = runtime_start - prepare_start;

      for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
      {
        hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

        if (user_options_extra->wordlist_mode == WL_MODE_STDIN)
        {
          hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
        }
        else
        {
          hc_thread_create (c_threads[device_id], thread_calc, device_param);
        }
      }

      hc_thread_wait (opencl_ctx->devices_cnt, c_threads);

      local_free (c_threads);

      if ((opencl_ctx->devices_status != STATUS_CRACKED)
       && (opencl_ctx->devices_status != STATUS_ABORTED)
       && (opencl_ctx->devices_status != STATUS_QUIT)
       && (opencl_ctx->devices_status != STATUS_BYPASS))
      {
        opencl_ctx->devices_status = STATUS_EXHAUSTED;
      }

      logfile_sub_var_uint ("status-after-work", opencl_ctx->devices_status);

      user_options->restore = false;

      if (induct_ctx->induction_dictionaries_cnt)
      {
        unlink (induct_ctx->induction_dictionaries[0]);
      }

      myfree (induct_ctx->induction_dictionaries);

      induct_ctx_scan (induct_ctx);

      if (user_options->benchmark == true)
      {
        status_benchmark (opencl_ctx, hashconfig, user_options);

        if (user_options->machine_readable == false)
        {
          log_info ("");
        }
      }
      else
      {
        if (user_options->quiet == false)
        {
          clear_prompt ();

          log_info ("");

          status_display (opencl_ctx, hashconfig, hashes, user_options, user_options_extra, rules_ctx);

          log_info ("");
        }
        else
        {
          if (user_options->status == true)
          {
            status_display (opencl_ctx, hashconfig, hashes, user_options, user_options_extra, rules_ctx);
          }
        }
      }

      if (induct_ctx->induction_dictionaries_cnt)
      {
        // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time)

        dictpos--;
      }

      /**
       * Update loopback file
       */

      if (user_options->loopback == true)
      {
        loopback_write_close (loopback_ctx);
      }

      time_t runtime_stop;

      time (&runtime_stop);

      data.runtime_stop = runtime_stop;

      logfile_sub_uint (runtime_start);
      logfile_sub_uint (runtime_stop);

      time (&prepare_start);

      logfile_sub_msg ("STOP");

      // finalize task

      if (opencl_ctx->run_main_level3 == false) break;
    }

    if (opencl_ctx->run_main_level2 == false) break;
  }

  // problems could occur if already at startup everything was cracked (because of .pot file reading etc), we must set some variables here to avoid NULL pointers
  if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
  {
    if (user_options_extra->wordlist_mode == WL_MODE_FILE)
    {
      if (data.dictfile == NULL)
      {
        if (dictfiles != NULL)
        {
          data.dictfile = dictfiles[0];

          hc_timer_set (&data.timer_running);
        }
      }
    }
  }
  // NOTE: combi is okay because it is already set beforehand
  else if (user_options->attack_mode == ATTACK_MODE_HYBRID1 || user_options->attack_mode == ATTACK_MODE_HYBRID2)
  {
    if (data.dictfile == NULL)
    {
      if (dictfiles != NULL)
      {
        hc_timer_set (&data.timer_running);

        data.dictfile = dictfiles[0];
      }
    }
  }
  else if (user_options->attack_mode == ATTACK_MODE_BF)
  {
    if (data.mask == NULL)
    {
      hc_timer_set (&data.timer_running);

      data.mask = masks[0];
    }
  }

  // if cracked / aborted remove last induction dictionary

  induct_ctx_cleanup (induct_ctx);

  // wait for inner threads

  data.shutdown_inner = 1;

  for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
  {
    hc_thread_wait (1, &inner_threads[thread_idx]);
  }

  local_free (inner_threads);

  // we dont need restore file anymore
  if (user_options->restore_disable == false)
  {
    if ((opencl_ctx->devices_status == STATUS_EXHAUSTED) || (opencl_ctx->devices_status == STATUS_CRACKED))
    {
      unlink (data.eff_restore_file);
      unlink (data.new_restore_file);
    }
    else
    {
      cycle_restore (opencl_ctx);
    }
  }

  // finally save left hashes

  if ((hashes->hashlist_mode == HL_MODE_FILE) && (user_options->remove == true) && (hashes->digests_saved != hashes->digests_done))
  {
    save_hash (user_options, hashconfig, hashes);
  }

  /**
   * Clean up
   */

  // reset default fan speed

  if (user_options->gpu_temp_disable == false)
  {
    if (user_options->gpu_temp_retain)
    {
      hc_thread_mutex_lock (mux_hwmon);

      for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
      {
        hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

        if (device_param->skipped) continue;

        if (data.hm_device[device_id].fan_set_supported == true)
        {
          int rc = -1;

          if (device_param->device_vendor_id == VENDOR_ID_AMD)
          {
            rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
          }
          else if (device_param->device_vendor_id == VENDOR_ID_NV)
          {
            #if defined (__linux__)
            rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
            #endif

            #if defined (_WIN)
            rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
            #endif
          }

          if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
        }
      }

      hc_thread_mutex_unlock (mux_hwmon);
    }
  }

  // reset power tuning

  if (user_options->powertune_enable == true)
  {
    hc_thread_mutex_lock (mux_hwmon);

    for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
    {
      hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

      if (device_param->skipped) continue;

      if (opencl_ctx->devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
      {
        if (data.hm_device[device_id].od_version == 6)
        {
          // check powertune capabilities first, if not available then skip device

          int powertune_supported = 0;

          if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
          {
            log_error ("ERROR: Failed to get ADL PowerControl Capabilities");

            return -1;
          }

          if (powertune_supported != 0)
          {
            // powercontrol settings

            if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
            {
              log_info ("ERROR: Failed to restore the ADL PowerControl values");

              return -1;
            }

            // clocks

            ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));

            performance_state->iNumberOfPerformanceLevels = 2;

            performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
            performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
            performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
            performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;

            if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
            {
              log_info ("ERROR: Failed to restore ADL performance state");

              return -1;
            }

            local_free (performance_state);
          }
        }
      }

      if (opencl_ctx->devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
      {
        unsigned int power_limit = nvml_power_limit[device_id];

        if (power_limit > 0)
        {
          hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, power_limit);
        }
      }
    }

    hc_thread_mutex_unlock (mux_hwmon);
  }

  if (user_options->gpu_temp_disable == false)
  {
    if (data.hm_nvml)
    {
      hm_NVML_nvmlShutdown (data.hm_nvml);

      nvml_close (data.hm_nvml);

      data.hm_nvml = NULL;
    }

    if (data.hm_nvapi)
    {
      hm_NvAPI_Unload (data.hm_nvapi);

      nvapi_close (data.hm_nvapi);

      data.hm_nvapi = NULL;
    }

    if (data.hm_xnvctrl)
    {
      hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);

      xnvctrl_close (data.hm_xnvctrl);

      data.hm_xnvctrl = NULL;
    }

    if (data.hm_adl)
    {
      hm_ADL_Main_Control_Destroy (data.hm_adl);

      adl_close (data.hm_adl);

      data.hm_adl = NULL;
    }
  }

  if (opencl_ctx->run_main_level1 == false) return -1;

  // free memory

  opencl_session_destroy (opencl_ctx);

  local_free (masks);

  debugfile_destroy (debugfile_ctx);

  potfile_write_close (potfile_ctx);

  potfile_destroy (potfile_ctx);

  dictstat_destroy (dictstat_ctx);

  loopback_destroy (loopback_ctx);

  wl_data_destroy (wl_data);

  bitmap_ctx_destroy (bitmap_ctx);

  hashes_destroy (hashes);

  hashconfig_destroy (hashconfig);

  local_free (od_clock_mem_status);
  local_free (od_power_control_status);
  local_free (nvml_power_limit);

  global_free (root_css_buf);
  global_free (markov_css_buf);

  global_free (words_progress_done);
  global_free (words_progress_rejected);
  global_free (words_progress_restored);

  return 0;
}

int main (int argc, char **argv)
{
  /**
   * To help users a bit
   */

  setup_console ();

  setup_environment_variables ();

  setup_umask ();

  /**
   * Real init
   */

  memset (&data, 0, sizeof (hc_global_data_t));

  time_t proc_start;

  time (&proc_start);

  data.proc_start = proc_start;

  hc_thread_mutex_init (mux_display);
  hc_thread_mutex_init (mux_hwmon);

  /**
   * folder
   */

  char *install_folder = NULL;
  char *shared_folder  = NULL;

  #if defined (INSTALL_FOLDER)
  install_folder = INSTALL_FOLDER;
  #endif

  #if defined (SHARED_FOLDER)
  shared_folder = SHARED_FOLDER;
  #endif

  folder_config_t *folder_config = (folder_config_t *) mymalloc (sizeof (folder_config_t));

  folder_config_init (folder_config, install_folder, shared_folder);

  /**
   * commandline parameters
   */

  user_options_t *user_options = (user_options_t *) mymalloc (sizeof (user_options_t));

  data.user_options = user_options;

  user_options_init (user_options, argc, argv);

  const int rc_user_options_parse = user_options_parse (user_options, argc, argv);

  if (rc_user_options_parse == -1) return -1;

  /**
   * session
   */

  char *eff_restore_file = (char *) mymalloc (HCBUFSIZ_TINY);
  char *new_restore_file = (char *) mymalloc (HCBUFSIZ_TINY);

  snprintf (eff_restore_file, HCBUFSIZ_TINY - 1, "%s/%s.restore",     folder_config->session_dir, user_options->session);
  snprintf (new_restore_file, HCBUFSIZ_TINY - 1, "%s/%s.restore.new", folder_config->session_dir, user_options->session);

  data.eff_restore_file = eff_restore_file;
  data.new_restore_file = new_restore_file;

  restore_data_t *rd = init_restore (argc, argv, user_options);

  data.rd = rd;

  /**
   * restore file
   */

  int    myargc = argc;
  char **myargv = argv;

  if (user_options->restore == true)
  {
    read_restore (eff_restore_file, rd);

    if (rd->version < RESTORE_VERSION_MIN)
    {
      log_error ("ERROR: Incompatible restore-file version");

      return -1;
    }

    myargc = rd->argc;
    myargv = rd->argv;

    #if defined (_POSIX)
    rd->pid = getpid ();
    #elif defined (_WIN)
    rd->pid = GetCurrentProcessId ();
    #endif

    user_options_init (user_options, myargc, myargv);

    const int rc_user_options_parse = user_options_parse (user_options, myargc, myargv);

    if (rc_user_options_parse == -1) return -1;
  }

  if (user_options->version == true)
  {
    log_info ("%s", VERSION_TAG);

    return 0;
  }

  if (user_options->usage == true)
  {
    usage_big_print (PROGNAME);

    return 0;
  }

  /**
   * process user input
   */

  user_options_extra_t *user_options_extra = (user_options_extra_t *) mymalloc (sizeof (user_options_extra_t));

  data.user_options_extra = user_options_extra;

  const int rc_user_options_extra_init = user_options_extra_init (user_options, myargc, myargv, user_options_extra);

  if (rc_user_options_extra_init == -1) return -1;

  const int rc_user_options_sanity = user_options_sanity (user_options, myargc, myargv, user_options_extra);

  if (rc_user_options_sanity == -1) return -1;

  /**
   * prepare seeding for random number generator, required by logfile and rules generator
   */

  setup_seeding (user_options, proc_start);

  /**
   * logfile init
   */

  logfile_ctx_t *logfile_ctx = (logfile_ctx_t *) mymalloc (sizeof (logfile_ctx_t));

  data.logfile_ctx = logfile_ctx;

  logfile_init (logfile_ctx, user_options, folder_config);

  logfile_generate_topid (logfile_ctx);

  logfile_top_msg ("START");

  user_options_logger (user_options, logfile_ctx);

  /**
   * Inform user things getting started,
   * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
   */

  welcome_screen (user_options, &proc_start);

  /**
   * tuning db
   */

  char tuning_db_file[256] = { 0 };

  snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", folder_config->shared_dir, TUNING_DB_FILE);

  tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);

  /**
   * induction directory
   */

  induct_ctx_t *induct_ctx = (induct_ctx_t *) mymalloc (sizeof (induct_ctx_t));

  data.induct_ctx = induct_ctx;

  const int rc_induct_ctx_init = induct_ctx_init (induct_ctx, user_options, folder_config, proc_start);

  if (rc_induct_ctx_init == -1) return -1;

  /**
   * outfile-check directory
   */

  outcheck_ctx_t *outcheck_ctx = (outcheck_ctx_t *) mymalloc (sizeof (outcheck_ctx_t));

  data.outcheck_ctx = outcheck_ctx;

  const int rc_outcheck_ctx_init = outcheck_ctx_init (outcheck_ctx, user_options, folder_config);

  if (rc_outcheck_ctx_init == -1) return -1;

  /**
   * outfile itself
   */

  outfile_ctx_t *outfile_ctx = mymalloc (sizeof (outfile_ctx_t));

  data.outfile_ctx = outfile_ctx;

  outfile_init (outfile_ctx, user_options);

  /**
   * Sanity check for hashfile vs outfile (should not point to the same physical file)
   */

  const int rc_outfile_and_hashfile = outfile_and_hashfile (outfile_ctx, myargv[user_options_extra->optind]);

  if (rc_outfile_and_hashfile == -1) return -1;

  /**
   * cpu affinity
   */

  if (user_options->cpu_affinity)
  {
    set_cpu_affinity (user_options->cpu_affinity);
  }

  /**
   * rules
   */

  rules_ctx_t *rules_ctx = (rules_ctx_t *) mymalloc (sizeof (rules_ctx_t));

  data.rules_ctx = rules_ctx;

  const int rc_rules_init = rules_ctx_init (rules_ctx, user_options);

  if (rc_rules_init == -1) return -1;

  /**
   * Init OpenCL library loader
   */

  opencl_ctx_t *opencl_ctx = (opencl_ctx_t *) mymalloc (sizeof (opencl_ctx_t));

  data.opencl_ctx = opencl_ctx;

  const int rc_opencl_init = opencl_ctx_init (opencl_ctx, user_options);

  if (rc_opencl_init == -1)
  {
    log_error ("ERROR: opencl_ctx_init() failed");

    return -1;
  }

  /**
   * Init OpenCL devices
   */

  const int rc_devices_init = opencl_ctx_devices_init (opencl_ctx, user_options);

  if (rc_devices_init == -1)
  {
    log_error ("ERROR: opencl_ctx_devices_init() failed");

    return -1;
  }

  /**
   * keypress thread
   */

  uint outer_threads_cnt = 0;

  hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));

  data.shutdown_outer = 0;

  if (user_options->keyspace == false && user_options->benchmark == false && user_options->stdout_flag == false)
  {
    if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK))
    {
      hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);

      outer_threads_cnt++;
    }
  }

  /**
   * outer loop
   */

  if (user_options->benchmark == true)
  {
    user_options->quiet = true;

    if (user_options->hash_mode_chgd == true)
    {
      const int rc = outer_loop (user_options, user_options_extra, myargc, myargv, folder_config, logfile_ctx, tuning_db, induct_ctx, outcheck_ctx, outfile_ctx, rules_ctx, opencl_ctx);

      if (rc == -1) return -1;
    }
    else
    {
      for (int algorithm_pos = 0; algorithm_pos < DEFAULT_BENCHMARK_ALGORITHMS_CNT; algorithm_pos++)
      {
        user_options->hash_mode = DEFAULT_BENCHMARK_ALGORITHMS_BUF[algorithm_pos];

        const int rc = outer_loop (user_options, user_options_extra, myargc, myargv, folder_config, logfile_ctx, tuning_db, induct_ctx, outcheck_ctx, outfile_ctx, rules_ctx, opencl_ctx);

        if (rc == -1) return -1;
      }
    }
  }
  else
  {
    const int rc = outer_loop (user_options, user_options_extra, myargc, myargv, folder_config, logfile_ctx, tuning_db, induct_ctx, outcheck_ctx, outfile_ctx, rules_ctx, opencl_ctx);

    if (rc == -1) return -1;
  }

  // wait for outer threads

  data.shutdown_outer = 1;

  for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
  {
    hc_thread_wait (1, &outer_threads[thread_idx]);
  }

  local_free (outer_threads);

  // destroy others mutex

  hc_thread_mutex_delete (mux_display);
  hc_thread_mutex_delete (mux_hwmon);

  // free memory

  local_free (eff_restore_file);
  local_free (new_restore_file);

  local_free (rd);

  rules_ctx_destroy (rules_ctx);

  tuning_db_destroy (tuning_db);

  induct_ctx_destroy (induct_ctx);

  outfile_destroy (outfile_ctx);

  outcheck_ctx_destroy (outcheck_ctx);

  folder_config_destroy (folder_config);

  user_options_extra_destroy (user_options_extra);

  opencl_ctx_devices_destroy (opencl_ctx);

  time_t proc_stop;

  time (&proc_stop);

  logfile_top_uint (proc_start);
  logfile_top_uint (proc_stop);

  logfile_top_msg ("STOP");

  logfile_destroy (logfile_ctx);

  goodbye_screen (user_options, &proc_start, &proc_stop);

  user_options_destroy (user_options);

  u32 rc_final = -1;

  if (opencl_ctx->devices_status == STATUS_ABORTED)   rc_final = 2;
  if (opencl_ctx->devices_status == STATUS_QUIT)      rc_final = 2;
  if (opencl_ctx->devices_status == STATUS_EXHAUSTED) rc_final = 1;
  if (opencl_ctx->devices_status == STATUS_CRACKED)   rc_final = 0;

  opencl_ctx_destroy (opencl_ctx);

  return rc_final;
}