};
// weakens the target server. should be finished running before running main schedule
const array_make_schedule_weaken = function(ns, integer_job_cap, float_padding_seconds, string_server_target_argument) {
  void_debug(array_make_schedule_weaken, Array.from(arguments));
  const object_scripts = object_get_constants(ns).object_scripts;
  const array_servers_rooted_sorted_by_ram = array_get_servers_rooted_sorted_by_ram(ns);
  let string_server_target = string_server_target_argument;
  if (string_server_target_argument === null) {
    string_server_target = string_get_server_rooted_hackable_with_score_biggest(ns);
  }
  const float_server_target_security_minimum = ns.getServerMinSecurityLevel(string_server_target);
  const float_time_weaken = float_get_time_weaken(ns, string_server_target, ns.getServerSecurityLevel(string_server_target));
  let float_server_target_security_current = ns.getServerSecurityLevel(string_server_target);
  let array_schedule_weaken = [];
  let integer_array_schedule_weaken_length = 0;
  // assumes weaken takes longest
  let integer_time_job_finishes_seconds = float_time_weaken;
  // iterate through servers in reverse to use servers with the biggest rams first
  for (let integer_indices_0 = array_servers_rooted_sorted_by_ram.length - 1; integer_indices_0 >= 0; --integer_indices_0) {
    if (float_server_target_security_current <= float_server_target_security_minimum ||
      integer_array_schedule_weaken_length >= integer_job_cap) {
      break;
    }
    const string_server_used = array_servers_rooted_sorted_by_ram[integer_indices_0];
    let float_server_used_ram_free_current = float_get_server_ram_free(ns, string_server_used);
    while (
      float_server_target_security_current > float_server_target_security_minimum &&
      float_server_used_ram_free_current > 0 &&
      integer_array_schedule_weaken_length < integer_job_cap
    ) {
      let schedule_item = {
        string_job: "weaken",
        string_server_used: string_server_used,
        string_server_target: string_server_target,
        float_server_target_security_before: float_server_target_security_current
      };
      if (!bool_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.weaken.ram, 1)) {
        // ram of the currently used server isn't actually 0, we're just doing this to skip it and start using a server with more ram
        float_server_used_ram_free_current = 0;
        break;
      }
      const integer_threads_weaken = integer_get_threads_weaken(ns, float_server_used_ram_free_current, string_server_target, float_server_target_security_current);
      float_server_used_ram_free_current -= integer_threads_weaken * object_scripts.weaken.ram;
      
      const float_server_target_security_uncorrected = float_server_target_security_current - float_get_security_decrease_from_weaken(ns, integer_threads_weaken);
      if (float_server_target_security_uncorrected < float_server_target_security_minimum) {
        float_server_target_security_current = float_server_target_security_minimum;
      }
      else {
        float_server_target_security_current = float_server_target_security_uncorrected;
      }
      schedule_item.float_delay_seconds = integer_time_job_finishes_seconds - float_time_weaken + float_padding_seconds;
      integer_time_job_finishes_seconds += float_padding_seconds;
      schedule_item.integer_time_job_finishes_seconds = integer_time_job_finishes_seconds;
      schedule_item.integer_threads = integer_threads_weaken;
      array_schedule_weaken.push(schedule_item);
      ++integer_array_schedule_weaken_length;
      break;
    }
  }
  return array_schedule_weaken;

// makes the actual weakening, growing and hacking schedule

  // remove schedule items near the end that cause security to not equal minimum. in other words, the target should have minimum security when the cycle finishes. this is to make the next cycle of jobs run as quick as possible. TODO: make it so that we don't have to do this deleting step, instead, the array making steps above should already take into this into account and don't make more items than is needed.
  let boolean_have_not_seen_item_with_security_minimum = true;
  while (boolean_have_not_seen_item_with_security_minimum) {
    for (let integer_indices_1 = array_schedule.length - 1; integer_indices_1 >= 0; --integer_indices_1) {
      if (boolean_have_not_seen_item_with_security_minimum === false) {
        break;
      }
      const object_job = array_schedule[integer_indices_1];
      if (object_job.float_server_target_security_before === float_server_target_security_minimum) {
        boolean_have_not_seen_item_with_security_minimum = false;
        array_schedule.splice(integer_indices_1, 1);
        break;
      }
      else {
        array_schedule.splice(integer_indices_1, 1);
      }
    }
  }

  // weaken target if necessary to reduce the time it takes to finish later jobs
  const array_schedule_weaken = array_make_schedule_weaken(ns, integer_job_cap, float_padding_seconds, string_server_target);
  if (array_schedule_weaken.length >= 1) {
    for (let integer_indices_0 = 0; integer_indices_0 < array_schedule_weaken.length; ++integer_indices_0) {
      await void_exec_script_weaken(ns, array_schedule_weaken[integer_indices_0].string_server_used, array_schedule_weaken[integer_indices_0].string_server_target, array_schedule_weaken[integer_indices_0].integer_threads, array_schedule_weaken[integer_indices_0].float_delay_seconds * 1000, integer_indices_0);
      break;
    }
    await ns.sleep(array_schedule_weaken[array_schedule_weaken.length - 1].integer_time_job_finishes_seconds * 1000);
  }
  // make and run actual schedule

    ns.tprint(`Copied the file "${string_file_to_copy}" located in the server "${string_server_source}".`);