substr( $curr_path, 0, strlen( $curr_path_previous ) ) != $curr_path_previous ) {
                    return false;
                }
                $curr_path_previous = $curr_path;
            }
        }
 
        return true;
    }
 
    /**
     * Recursive remove dir
     *
     * @param string  $path
     * @param array   $exclude
     * @param bool    $remove
     * @return void
     */
    static public function rmdir( $path, $exclude = array(), $remove = true ) {
        $dir = file_exists( $path ) ? opendir( $path ) : false;
 
        if ( $dir ) {
            while ( ( $entry = @readdir( $dir ) ) !== false ) {
                if ( $entry == '.' || $entry == '..' ) {
                    continue;
                }
 
                foreach ( $exclude as $mask ) {
                    if ( fnmatch( $mask, basename( $entry ) ) ) {
                        continue 2;
                    }
                }
 
                $full_path = $path . DIRECTORY_SEPARATOR . $entry;
 
                if ( @is_dir( $full_path ) ) {
                    Util_File::rmdir( $full_path, $exclude );
                } else {
                    @unlink( $full_path );
                }

     */
    static public function rmdir( $path, $exclude = array(), $remove = true ) {
        $dir = file_exists( $path ) ? opendir( $path ) : false;
 
        if ( $dir ) {
            while ( ( $entry = @readdir( $dir ) ) !== false ) {
                if ( $entry == '.' || $entry == '..' ) {
                    continue;
                }
 
                foreach ( $exclude as $mask ) {
                    if ( fnmatch( $mask, basename( $entry ) ) ) {
                        continue 2;
                    }
                }
 
                $full_path = $path . DIRECTORY_SEPARATOR . $entry;
 
                if ( @is_dir( $full_path ) ) {
                    Util_File::rmdir( $full_path, $exclude );
                } else {
                    @unlink( $full_path );
                }
            }
 
            @closedir( $dir );
 
            if ( $remove ) {
                @rmdir( $path );
            }
        }
    }
 
    /**
     * Recursive empty dir
     *
     * @param string  $path
     * @param array   $exclude
     * @return void
     */

                }
            }
 
            @closedir( $dir );
 
            if ( $remove ) {
                @rmdir( $path );
            }
        }
    }
 
    /**
     * Recursive empty dir
     *
     * @param string  $path
     * @param array   $exclude
     * @return void
     */
    static public function emptydir( $path, $exclude = array() ) {
        Util_File::rmdir( $path, $exclude, false );
    }
 
    /**
     * Check if file is write-able
     *
     * @param string  $file
     * @return boolean
     */
    static public function is_writable( $file ) {
        $exists = file_exists( $file );
 
        $fp = @fopen( $file, 'a' );
 
        if ( $fp ) {
            fclose( $fp );
 
            if ( !$exists ) {
                @unlink( $file );
            }
 

 
    /**
     * Flushes all data
     *
     * @param string  $group Used to differentiate between groups of cache values
     * @return boolean
     */
    function flush( $group = '' ) {
        @set_time_limit( $this->_flush_timelimit );
 
        if ( 'sitemaps' === $group ) {
            $config = Dispatcher::config();
            $sitemap_regex = $config->get_string( 'pgcache.purge.sitemap_regex' );
            $this->_flush_based_on_regex( $sitemap_regex );
        } else {
            $flush_dir = $group ?
                $this->_cache_dir . DIRECTORY_SEPARATOR . $group .
                DIRECTORY_SEPARATOR :
                $this->_flush_dir;
            Util_File::emptydir( $flush_dir, $this->_exclude );
        }
 
        return true;
    }
 
    /**
     * Gets a key extension for "ahead generation" mode.
     * Used by AlwaysCached functionality to regenerate content
     *
     * @param string $group Used to differentiate between groups of cache values.
     *
     * @return array
     */
    public function get_ahead_generation_extension( $group ) {
        return array(
            'before_time' => time(),
        );
    }
 
    /**

        }
        if ( $this->_config->get_boolean( 'dbcache.debug_purge' ) ) {
            Util_Debug::log_purge(
                'dbcache',
                '_flush_cache_for_sql_group',
                array( $group, $extras )
            );
        }
 
        $cache        = $this->_get_cache();
        $flush_groups = $this->_get_flush_groups( $group, $extras );
        $v            = true;
 
        $this->cache_flushes++;
 
        foreach ( $flush_groups as $f_group => $nothing ) {
            if ( $this->debug ) {
                $filename = Util_Debug::log( 'dbcache', 'flush group ' . $f_group );
            }
            $v &= $cache->flush( $f_group );
        }
 
        $this->time_total += $this->wpdb_mixin->timer_stop();
 
        return $v;
    }
 
    /**
     * Returns cache object.
     *
     * @return W3_Cache_Base
     */
    public function _get_cache() {
        static $cache = array();
 
        if ( ! isset( $cache[0] ) ) {
            $engine = $this->_config->get_string( 'dbcache.engine' );
 
            switch ( $engine ) {
                case 'memcached':

 
            $this->wpdb_mixin->last_error  = $data['last_error'];
            $this->wpdb_mixin->last_query  = $data['last_query'];
            $this->wpdb_mixin->last_result = $data['last_result'];
            $this->wpdb_mixin->col_info    = $data['col_info'];
            $this->wpdb_mixin->num_rows    = $data['num_rows'];
            $return_val                    = $data['return_val'];
        } else {
            $this->query_misses++;
 
            $this->wpdb_mixin->timer_start();
            $return_val = $this->next_injection->query( $query );
            $time_total = $this->wpdb_mixin->timer_stop();
 
            if ( $flush_after_query ) {
                $group = $this->_get_group( $query );
 
                $this->_flush_cache_for_sql_group(
                    $group,
                    array( 'modification_query' => $query )
                );
            }
 
            if ( $caching ) {
                $data = array(
                    'last_error'  => $this->wpdb_mixin->last_error,
                    'last_query'  => $this->wpdb_mixin->last_query,
                    'last_result' => $this->wpdb_mixin->last_result,
                    'col_info'    => $this->wpdb_mixin->col_info,
                    'num_rows'    => $this->wpdb_mixin->num_rows,
                    'return_val'  => $return_val,
                );
 
                $cache = $this->_get_cache();
                $group = $this->_get_group( $query );
 
                $filter_data = array(
                    'query'      => $query,
                    'group'      => $group,
                    'content'    => $data,

    /**
     * Initializes object after processors configured. Called from instance() only
     */
    public function initialize() {
        return $this->active_processor->initialize();
    }
 
    /**
     * Overriten logic of wp_db by processor.
     */
    public function insert( $table, $data, $format = null ) {
        do_action( 'w3tc_db_insert', $table, $data, $format );
        return $this->active_processor->insert( $table, $data, $format );
    }
 
    /**
     * Overriten logic of wp_db by processor.
     */
    public function query( $query ) {
        return $this->active_processor->query( $query );
    }
 
    public function _escape( $data ) {
        return $this->active_processor->_escape( $data );
    }
 
    /**
     * Overriten logic of wp_db by processor.
     */
    public function prepare( $query, ...$args ) {
        return $this->active_processor->prepare( $query, $args );
    }
 
    /**
     * Overriten logic of wp_db by processor.
     */
    public function replace( $table, $data, $format = null ) {
        do_action( 'w3tc_db_replace', $table, $data, $format );
        return $this->active_processor->replace( $table, $data, $format );
    }

    public static function get_lock( $name, $expires_in = 30 ) {
 
        $pre_check = apply_filters( 'itsec_pre_get_lock', null, $name, $expires_in );
 
        if ( null !== $pre_check ) {
            return $pre_check;
        }
 
        /** @var \wpdb $wpdb */
        global $wpdb;
        $main_options = $wpdb->base_prefix . 'options';
 
        $lock       = "itsec-lock-{$name}";
        $now        = ITSEC_Core::get_current_time_gmt();
        $release_at = $now + $expires_in;
 
        if ( is_multisite() ) {
            $result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `{$main_options}` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, 'no') /* LOCK */", $lock, $release_at ) );
        } else {
            $result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, 'no') /* LOCK */", $lock, $release_at ) );
        }
 
        // The lock exists. See if it has expired.
        if ( ! $result ) {
 
            if ( is_multisite() && get_current_blog_id() !== 1 ) {
                $locked_until = $wpdb->get_var( $wpdb->prepare( "SELECT `option_value` FROM {$main_options} WHERE `option_name` = %s", $main_options ) );
            } else {
                $locked_until = get_option( $lock );
            }
 
            if ( ! $locked_until ) {
                // Can't write or read the lock. Bail due to an unknown and hopefully temporary error.
                return false;
            }
 
            if ( $locked_until > $now ) {
                // The lock still exists and has not expired.
                return false;
            }

    }
 
    $time = ITSEC_Modules::get_setting( 'global', 'cron_test_time' );
 
    if ( ! $time ) {
        if ( ITSEC_Lib::get_lock( 'cron_test_fail_safe' ) ) {
            ITSEC_Lib::schedule_cron_test();
            ITSEC_Lib::release_lock( 'cron_test_fail_safe' );
        }
 
        return;
    }
 
    $threshold = HOUR_IN_SECONDS + DAY_IN_SECONDS;
 
    if ( ITSEC_Core::get_current_time_gmt() <= $time + $threshold + 5 * MINUTE_IN_SECONDS ) {
        return;
    }
 
    if ( ! ITSEC_Lib::get_lock( 'cron_test_fail_safe' ) ) {
        return;
    }
 
    $uncached = ITSEC_Lib::get_uncached_option( 'itsec-storage' );
    $time     = $uncached['global']['cron_test_time'];
 
    if ( ITSEC_Core::get_current_time_gmt() > $time + $threshold + 5 * MINUTE_IN_SECONDS ) {
        if ( ( ! defined( 'ITSEC_USE_CRON' ) || ! ITSEC_USE_CRON ) && ITSEC_Lib::use_cron() ) {
            ITSEC_Modules::set_setting( 'global', 'use_cron', false );
        }
 
        ITSEC_Modules::set_setting( 'global', 'cron_status', 0 );
    }
 
    ITSEC_Lib::schedule_cron_test();
    ITSEC_Lib::release_lock( 'cron_test_fail_safe' );
}
 
add_action( 'init', 'itsec_cron_test_fail_safe' );
 

 
        $this->iterations[ $nesting_level ] = $this->priorities;
 
        $num_args = count( $args );
 
        do {
            $this->current_priority[ $nesting_level ] = current( $this->iterations[ $nesting_level ] );
 
            $priority = $this->current_priority[ $nesting_level ];
 
            foreach ( $this->callbacks[ $priority ] as $the_ ) {
                if ( ! $this->doing_action ) {
                    $args[0] = $value;
                }
 
                // Avoid the array_slice() if possible.
                if ( 0 === $the_['accepted_args'] ) {
                    $value = call_user_func( $the_['function'] );
                } elseif ( $the_['accepted_args'] >= $num_args ) {
                    $value = call_user_func_array( $the_['function'], $args );
                } else {
                    $value = call_user_func_array( $the_['function'], array_slice( $args, 0, $the_['accepted_args'] ) );
                }
            }
        } while ( false !== next( $this->iterations[ $nesting_level ] ) );
 
        unset( $this->iterations[ $nesting_level ] );
        unset( $this->current_priority[ $nesting_level ] );
 
        --$this->nesting_level;
 
        return $value;
    }
 
    /**
     * Calls the callback functions that have been added to an action hook.
     *
     * @since 4.7.0
     *
     * @param array $args Parameters to pass to the callback functions.

        } while ( false !== next( $this->iterations[ $nesting_level ] ) );
 
        unset( $this->iterations[ $nesting_level ] );
        unset( $this->current_priority[ $nesting_level ] );
 
        --$this->nesting_level;
 
        return $value;
    }
 
    /**
     * Calls the callback functions that have been added to an action hook.
     *
     * @since 4.7.0
     *
     * @param array $args Parameters to pass to the callback functions.
     */
    public function do_action( $args ) {
        $this->doing_action = true;
        $this->apply_filters( '', $args );
 
        // If there are recursive calls to the current action, we haven't finished it until we get to the last one.
        if ( ! $this->nesting_level ) {
            $this->doing_action = false;
        }
    }
 
    /**
     * Processes the functions hooked into the 'all' hook.
     *
     * @since 4.7.0
     *
     * @param array $args Arguments to pass to the hook callbacks. Passed by reference.
     */
    public function do_all_hook( &$args ) {
        $nesting_level                      = $this->nesting_level++;
        $this->iterations[ $nesting_level ] = $this->priorities;
 
        do {
            $priority = current( $this->iterations[ $nesting_level ] );

    if ( ! isset( $wp_filter[ $hook_name ] ) ) {
        if ( isset( $wp_filter['all'] ) ) {
            array_pop( $wp_current_filter );
        }
 
        return;
    }
 
    if ( ! isset( $wp_filter['all'] ) ) {
        $wp_current_filter[] = $hook_name;
    }
 
    if ( empty( $arg ) ) {
        $arg[] = '';
    } elseif ( is_array( $arg[0] ) && 1 === count( $arg[0] ) && isset( $arg[0][0] ) && is_object( $arg[0][0] ) ) {
        // Backward compatibility for PHP4-style passing of `array( &$this )` as action `$arg`.
        $arg[0] = $arg[0][0];
    }
 
    $wp_filter[ $hook_name ]->do_action( $arg );
 
    array_pop( $wp_current_filter );
}
 
/**
 * Calls the callback functions that have been added to an action hook, specifying arguments in an array.
 *
 * @since 2.1.0
 *
 * @see do_action() This function is identical, but the arguments passed to the
 *                  functions hooked to `$hook_name` are supplied using an array.
 *
 * @global WP_Hook[] $wp_filter         Stores all of the filters and actions.
 * @global int[]     $wp_actions        Stores the number of times each action was triggered.
 * @global string[]  $wp_current_filter Stores the list of current filters with the current one last.
 *
 * @param string $hook_name The name of the action to be executed.
 * @param array  $args      The arguments supplied to the functions hooked to `$hook_name`.
 */
function do_action_ref_array( $hook_name, $args ) {

if ( ! class_exists( 'WP_Site_Health' ) ) {
    require_once ABSPATH . 'wp-admin/includes/class-wp-site-health.php';
}
WP_Site_Health::get_instance();
 
// Set up current user.
$GLOBALS['wp']->init();
 
/**
 * Fires after WordPress has finished loading but before any headers are sent.
 *
 * Most of WP is loaded at this stage, and the user is authenticated. WP continues
 * to load on the {@see 'init'} hook that follows (e.g. widgets), and many plugins instantiate
 * themselves on it for all sorts of reasons (e.g. they need a user, a taxonomy, etc.).
 *
 * If you wish to plug an action once WP is loaded, use the {@see 'wp_loaded'} hook below.
 *
 * @since 1.5.0
 */
do_action( 'init' );
 
// Check site status.
if ( is_multisite() ) {
    $file = ms_site_check();
    if ( true !== $file ) {
        require $file;
        die();
    }
    unset( $file );
}
 
/**
 * This hook is fired once WP, all plugins, and the theme are fully loaded and instantiated.
 *
 * Ajax requests should use wp-admin/admin-ajax.php. admin-ajax.php can handle requests for
 * users not logged in.
 *
 * @link https://developer.wordpress.org/plugins/javascript/ajax
 *
 * @since 3.0.0

 * It is strongly recommended that plugin and theme developers use WP_DEBUG
 * in their development environments.
 *
 * For information on other constants that can be used for debugging,
 * visit the documentation.
 *
 * @link https://wordpress.org/support/article/debugging-in-wordpress/
 */
define( 'WP_DEBUG', false );
define('WP_ENV', 'development');

/* That's all, stop editing! Happy publishing. */

/** Absolute path to the WordPress directory. */
if ( ! defined( 'ABSPATH' ) ) {
    define( 'ABSPATH', __DIR__ . '/' );
}

/** Sets up WordPress vars and included files. */
require_once ABSPATH . 'wp-settings.php';
 

     * Initialize error reporting to a known set of levels.
     *
     * This will be adapted in wp_debug_mode() located in wp-includes/load.php based on WP_DEBUG.
     * @see https://www.php.net/manual/en/errorfunc.constants.php List of known error levels.
     */
    error_reporting( E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR | E_USER_WARNING | E_RECOVERABLE_ERROR );
}
 
/*
 * If wp-config.php exists in the WordPress root, or if it exists in the root and wp-settings.php
 * doesn't, load wp-config.php. The secondary check for wp-settings.php has the added benefit
 * of avoiding cases where the current directory is a nested installation, e.g. / is WordPress(a)
 * and /blog/ is WordPress(b).
 *
 * If neither set of conditions is true, initiate loading the setup process.
 */
if ( file_exists( ABSPATH . 'wp-config.php' ) ) {
 
    /** The config file resides in ABSPATH */
    require_once ABSPATH . 'wp-config.php';
 
} elseif ( @file_exists( dirname( ABSPATH ) . '/wp-config.php' ) && ! @file_exists( dirname( ABSPATH ) . '/wp-settings.php' ) ) {
 
    /** The config file resides one level above ABSPATH but is not part of another installation */
    require_once dirname( ABSPATH ) . '/wp-config.php';
 
} else {
 
    // A config file doesn't exist.
 
    define( 'WPINC', 'wp-includes' );
    require_once ABSPATH . WPINC . '/version.php';
    require_once ABSPATH . WPINC . '/compat.php';
    require_once ABSPATH . WPINC . '/load.php';
 
    // Check for the required PHP version and for the MySQL extension or a database drop-in.
    wp_check_php_mysql_versions();
 
    // Standardize $_SERVER variables across setups.
    wp_fix_server_vars();

<?php
/**
 * Loads the WordPress environment and template.
 *
 * @package WordPress
 */
 
if ( ! isset( $wp_did_header ) ) {
 
    $wp_did_header = true;
 
    // Load the WordPress library.
    require_once __DIR__ . '/wp-load.php';
 
    // Set up the WordPress query.
    wp();
 
    // Load the theme template.
    require_once ABSPATH . WPINC . '/template-loader.php';
 
}
 

<?php
/**
 * Front to the WordPress application. This file doesn't do anything, but loads
 * wp-blog-header.php which does and tells WordPress to load the theme.
 *
 * @package WordPress
 */
 
/**
 * Tells WordPress to load the WordPress theme and output it.
 *
 * @var bool
 */
define( 'WP_USE_THEMES', true );
 
/** Loads the WordPress Environment and Template */
require __DIR__ . '/wp-blog-header.php';