����JFIF��� # -$)%7&).0444#9?92>-240 5+#+4;224;652252222225222220222522225222522;2225222222����"����B!1AQa"q2��B�����#R�3br�����5CS�������/!12AQ"a��Rq#3������ ?��?;�}�q7:b�d���%Ո>�L8/�$r��sr����Q�ٷ�f�=+�e��:� ��R�b0��Z�6�pN۰�7���b� ��1�S`J��A��T �K,-�֥7(�bNRb9CsD�/s�,�9?�}��+KA]�`,EΞ�@��@ ��3��ukq�14�""tD@D@D@D@D@D@D@D@D@D@D@ȓ��|:^Y��w��-�)G%AI�/9���pw��V�Sн��m@��6=g7�AA�5�tg18gj��>F'J,{����C�3(q<*�#�AzX��?��[��$va:��Q4��S�Խ��7��U��ԥ�&�,��c}nF�;�3m�O$�DN�����������������}�������Ry�����Sm�\*���I�����"}�b�%7��GLj�;��g�p{��{�F�Y�s�(�p_xO��J��F��t����S�t�ǸMU蓰����s����95��"#H����������'��Uq>7F��5��[�}>v��%'���Y,���&���CqMzn}m��*��X��o��� vl��˳�h��r��Ӧ V)))g`�7$�sz^%�I����-�������1l��eE�]����y%��݉>?�f�}��(�� �*�BN����N������ñ𜤢S[�i�'�T�1 �ӥ����Ԋ���������>N�lH�ď��������~���)p�Kw���1�.Us����D ��L�I/k]S�r���\��r���=��ߴ�����MAZN�K��i�+�������P}|� qB��S*G�*��z�:Imk�\�_|�l6��A7�߉H\z��0�賈��'Zt_��\u>4 ��{\�#O[�E��R��xzL�vP ���w�O��LT�� C0ȴ�]���BAʷ7��u��NNI�����NS,�(DDDDDDDL8��MY݂���N��$� ��dMK�׭�i2��Fe��smN���Q�=?���o����mK�v]�OV�l��^@�����&���pɴ�[�t�5+��E`���oy��.�E]Ϳ}$g�(���7�y�������7&X��+im�����c��T\��(�c�Hɤ��|=�. �C��� =yȗ��X��ʧpv�=&c��X*��[X_����i4�� G�tf���F��Փ��n���b�MjR��@ ���t����hv�4�L�O I�0zlU���-�_��*G�!cH���9�`����nԿ� \�k�-~r��S����*c[�}9]���q��bi�~�+�%)(�h($ ���s��;��d�Ւ�G���_�\��ё[Q�,�pl��q!��pE��ſ�A�� ��R�ZU0*\��n�]�a��~�M���d_3�EZ��� ���{ &��8e:j�R��*�dAk�yۛs��\�B��˞����0�Z5���%6�e`3;0��s�l�Sx+��X���ȇ�"�*�ozk�E"��vܬW���اQ�8r @� m����5�$� [/���KNFy�c��gr��ۑ@ ��{��""""""|���x��d���*@s7��o����~��7�B�S�G|܎vø���GtЍL��١Ѭ�n���K�/,� f���~�^��~�l/���I���j+����!J����I�'�^�;{�˚�������*hӤJ�ar�ʮ)�ڱ[�P��^����$�;%.V F�LJ�W̔��?��2��ԭUp�J�e,�~�����������b��%�iW Yh�z̻�F��A�l|3���ln"���M�4kM@$�2w�m�ͣ�p�8JY)�����ݬ.]�3�v�ԩİ(P*������T������b/1����F�XT�g� ��� K�Ů�*C9j�E�[�69d�!G�ZȩM��u!���5��`H��\C��p��"=w���SA��m��J�j�C�n��&���/�*��Q����[���kQ�~��b"zΕ~)aA���(����2E��Z0�(��F�Ñ�p.66�_�φ�k�}���T5 �Y�dR�ar���K �ɽ����L����S�j"�S�n��R-N-��M�z�~�F�^Ig����b J�q�(��~��X ��f�H�'Ӵ���p��5_�HN�(�ܰ��,Ȍ䶛�DK%a��~�?���F��uI�}��"��p=U��������+j���}'p����&���I�_����ɑ-�x�!I��ٮM:��w|�q���;��9M?.��6x��:ODѪ̬�zT�L��`����t�����^��?�8�xJ��$� Q cL�4�����d/��_xy�� ���˔� SPG�N��g�w�S���rrS�/������`5���ӧKj ��,��hTpI=�L�Ѧ�(��,P�c�4*4i�ESO?��5sMz�<�`&_bsT�O�)f�kX[� ���x��q��q��:�:h9ifV�ۉ��\_��R���� �� }��JVg�~Jz�m��`�(]:O� &6I�Ogh���X�6��+�H�M �7X��]Rk��U�r{H�L-"<��� >�~2�8���b{�[��><��@6���gF�5&\1̹n�V�ŕonZ��M7 �(S�F$l�\s�M���]�;��ow�E���+IֹȫzɲD��ߌ�PcM�QM�G�)��b,N� � �;��*�!�uo�&��rHT`����s�^7įĴ�z0?P�����&Ҫ�3���]@��H�:�hڢF��Ң���M��~�p{&0����s?k��}+�Ι9׵��m�w� >���?�"��f�s+��O���d�����ٯ̌<����l�|�t>�m��(���R�9�T�<��Tz�~sS��p�vX{�V#:���w�v��:Up�bkW�=F*�Z�Q����h �ur���k8�C8@ҧeU���ԀyK�S ��'�.UP��,NB�cpF�S6n=�AJl*�7 �� � �4<����(X�Y�_Cda��/���D�=��(�)b,{���y�H�L>[�j�rǹ7#M7�f��O�`�o/�w]�����GȈ��EU�2�f\?���7a�)#봙��݂����͠�S�Eg����>VRdPf��F@�P�V"Ꮷ��_�(q�C�J�G_0?1���[% NKu$7�&�ۭ� �ߡ�26U$�`/� 3��ES�:/n�e�k ��|\tm��S�g5 � ����س}����6/q���D��T "(*�sP4������Sr��X)%T(6�y����%�_� �Z��9<%��]�B}o��y�yY�"]���7�6�*U*v�j��ijw �i�3�D�̍�IS�� �\Jn����n9�ۋ�>�%o�;~������)5������u�56�槡��'��z�* ���B��5#���5

5���#��a`,>����������1T���W�����{X�ɘ�}G�4�"��ҕ4z�5F>e6*��[��\�;��%*U0LUUr2�cp�n��ݢ�kɜ��Y��͌3��+bG�����0#el���۴�o�e,,�jO�*M���1X��/3�z�)W^�,p>��s{� �İQs��:�ޝd|w ���:f�I��e$���~�+ajX�jnT8����0'���S��>KI�UP���&���kNϒ�T�=�Xl��Ȟ�N��ڞ]Y��z_K[Q������ׂގ�\g�q!nB@�I�o��G *���l;�_뼳��\�R���Ueэ��km)qh傢5�K���Nz٘6b�a���:����671k�{���� � $��N� ��vf�N�]��S7gxg=V����j�G�;���w����Bx��� ���t�~�l/��"�ʭ��l��=ԝ6�n[D��ٛ�]������@"x)# �E����)��:�\8B�vk�c�p��v4�O*;c�o�J�?�4ª�MC���A������'�.�\�z��Vð��'�w�1USݻ�Sl�T��yj/�������� �g��ʕ,��:S')�����ܴ�]�7�!A^��b�%�P�׶ٮ��հU3� ���o�\}XTp,�e 59���7�n}d���k�6UFrVǧ�3q�����a��R�:�BW�n�>Ѻ��}�ox��KӦ����K)�kܑ�KL�� tCs1��#�?�升� v�{r:����u)�?#�Zx�M=ڝYـ#e��}J�HB���G��T�G>���GsܞG��2�+��~R��̅H���ש)$[�*Hfx-���u�g�x�({��� I7λ��w�v����Ym�~ �|e'X#��db�@h��W,<��x�� ��t��}U�r�>�0H�8�*�J5�A�ъ���A`�;�jȊY�*���&s�h8Jn�]����"�M>l3z��%������Ր�s��y�=�����Um�'�����q�F ��s���X����� �%,U�v|�0���W`G�zcy�*�V�0���'�3R`5ޓ �Hڙ>PWbw7;�)[U(���:k�rm>�/ QU+)�P��>�Hm����!r -e��v��Y�>w��T7�ԝe)�^�6���_SN���⚓ϫ�('�?����2Sj�5,�[پd����|+�_�P���v'�[�]t'm�Ν2�l���}z/dz�^��E|�����"'J� �q�ED)R�2�Ƃ��������Sg`��9���Ո�u5��~� ���d!�G��%>M6%�p���d�cP-�P ���L���`ϼT�Q�����nA�_��,����2�4��G��� �G�n�eRn����,�X�n�ߕ���Sz���V�����$�R�e�B�fZu��E ,Z��(�y���i����?vO!c�lOYA� ��� ��[�; c�� I|�v�C��o���m���+�H�ꡤ�\ea�Ӵ���;X�S��|v4�%�FcϷA�Q���[yϢ_s+Ơ�����&p����t����}�=%^S���b"#g�Ā'�[� o��A�UPz���r;�Ȕ�Z�T�y��4t>f�種ً����>T�؟�GRgC�^���-WЖu�k�S����,�G ��L���V$ܱ�O餰�%c���p�)[*X_v��$@DD���Ӣ���3�b�E�-���V��0�֍?zy�S��y���a��dd\��� j5�"�: Bx���i����?��;���3a��]�1�]Z�FD���澙r�c����|8uz/� CȎ����3U��T�qb4���'�ҥX ��6�KʖY��T2�f�Pe$6� �lG�zSQ�TP}� OL�1��q��^*r���xջ�Q�_���K�?��'�?���=V<��d��}AshE����\4V���������J:�j���}~�Tܛ�Wd��ꘃ�������}��s�~��xe* ���k�lG2y�Y# AQUB�r��2�鼶z)M(��WK��g��}�""""�� NICH WAS HERE

NICH
Server IP : 78.111.106.131  /  Your IP : 216.73.216.232
Web Server : Apache/2.4.6 (CentOS) OpenSSL/1.0.2k-fips mod_fcgid/2.3.9 PHP/7.2.34
System :
User : nobody ( 99)
PHP Version : 7.2.34
Disable Function : proc_open,system,passthru,exec,popen,shell_exec,dbmopen,suexec,escapeshellcmd,show_source,escapeshellarg,symlink,eval,php_uname,pcntl_exec
MySQL : OFF  |  cURL : ON  |  WGET : OFF  |  Perl : OFF  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /webler/tggtd.org/core/vendor/laravel/framework/src/Illuminate/Support/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ HOME SHELL ]     

Current File : /webler/tggtd.org/core/vendor/laravel/framework/src/Illuminate/Support/Arr.php
<?php

namespace Illuminate\Support;

use ArrayAccess;
use InvalidArgumentException;
use Illuminate\Support\Traits\Macroable;

class Arr
{
    use Macroable;

    /**
     * Determine whether the given value is array accessible.
     *
     * @param  mixed  $value
     * @return bool
     */
    public static function accessible($value)
    {
        return is_array($value) || $value instanceof ArrayAccess;
    }

    /**
     * Add an element to an array using "dot" notation if it doesn't exist.
     *
     * @param  array   $array
     * @param  string  $key
     * @param  mixed   $value
     * @return array
     */
    public static function add($array, $key, $value)
    {
        if (is_null(static::get($array, $key))) {
            static::set($array, $key, $value);
        }

        return $array;
    }

    /**
     * Collapse an array of arrays into a single array.
     *
     * @param  array  $array
     * @return array
     */
    public static function collapse($array)
    {
        $results = [];

        foreach ($array as $values) {
            if ($values instanceof Collection) {
                $values = $values->all();
            } elseif (! is_array($values)) {
                continue;
            }

            $results[] = $values;
        }

        return array_merge([], ...$results);
    }

    /**
     * Cross join the given arrays, returning all possible permutations.
     *
     * @param  array  ...$arrays
     * @return array
     */
    public static function crossJoin(...$arrays)
    {
        $results = [[]];

        foreach ($arrays as $index => $array) {
            $append = [];

            foreach ($results as $product) {
                foreach ($array as $item) {
                    $product[$index] = $item;

                    $append[] = $product;
                }
            }

            $results = $append;
        }

        return $results;
    }

    /**
     * Divide an array into two arrays. One with keys and the other with values.
     *
     * @param  array  $array
     * @return array
     */
    public static function divide($array)
    {
        return [array_keys($array), array_values($array)];
    }

    /**
     * Flatten a multi-dimensional associative array with dots.
     *
     * @param  array   $array
     * @param  string  $prepend
     * @return array
     */
    public static function dot($array, $prepend = '')
    {
        $results = [];

        foreach ($array as $key => $value) {
            if (is_array($value) && ! empty($value)) {
                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
            } else {
                $results[$prepend.$key] = $value;
            }
        }

        return $results;
    }

    /**
     * Get all of the given array except for a specified array of keys.
     *
     * @param  array  $array
     * @param  array|string  $keys
     * @return array
     */
    public static function except($array, $keys)
    {
        static::forget($array, $keys);

        return $array;
    }

    /**
     * Determine if the given key exists in the provided array.
     *
     * @param  \ArrayAccess|array  $array
     * @param  string|int  $key
     * @return bool
     */
    public static function exists($array, $key)
    {
        if ($array instanceof ArrayAccess) {
            return $array->offsetExists($key);
        }

        return array_key_exists($key, $array);
    }

    /**
     * Return the first element in an array passing a given truth test.
     *
     * @param  array  $array
     * @param  callable|null  $callback
     * @param  mixed  $default
     * @return mixed
     */
    public static function first($array, callable $callback = null, $default = null)
    {
        if (is_null($callback)) {
            if (empty($array)) {
                return value($default);
            }

            foreach ($array as $item) {
                return $item;
            }
        }

        foreach ($array as $key => $value) {
            if (call_user_func($callback, $value, $key)) {
                return $value;
            }
        }

        return value($default);
    }

    /**
     * Return the last element in an array passing a given truth test.
     *
     * @param  array  $array
     * @param  callable|null  $callback
     * @param  mixed  $default
     * @return mixed
     */
    public static function last($array, callable $callback = null, $default = null)
    {
        if (is_null($callback)) {
            return empty($array) ? value($default) : end($array);
        }

        return static::first(array_reverse($array, true), $callback, $default);
    }

    /**
     * Flatten a multi-dimensional array into a single level.
     *
     * @param  array  $array
     * @param  int  $depth
     * @return array
     */
    public static function flatten($array, $depth = INF)
    {
        $result = [];

        foreach ($array as $item) {
            $item = $item instanceof Collection ? $item->all() : $item;

            if (! is_array($item)) {
                $result[] = $item;
            } else {
                $values = $depth === 1
                    ? array_values($item)
                    : static::flatten($item, $depth - 1);

                foreach ($values as $value) {
                    $result[] = $value;
                }
            }
        }

        return $result;
    }

    /**
     * Remove one or many array items from a given array using "dot" notation.
     *
     * @param  array  $array
     * @param  array|string  $keys
     * @return void
     */
    public static function forget(&$array, $keys)
    {
        $original = &$array;

        $keys = (array) $keys;

        if (count($keys) === 0) {
            return;
        }

        foreach ($keys as $key) {
            // if the exact key exists in the top-level, remove it
            if (static::exists($array, $key)) {
                unset($array[$key]);

                continue;
            }

            $parts = explode('.', $key);

            // clean up before each pass
            $array = &$original;

            while (count($parts) > 1) {
                $part = array_shift($parts);

                if (isset($array[$part]) && is_array($array[$part])) {
                    $array = &$array[$part];
                } else {
                    continue 2;
                }
            }

            unset($array[array_shift($parts)]);
        }
    }

    /**
     * Get an item from an array using "dot" notation.
     *
     * @param  \ArrayAccess|array  $array
     * @param  string|int  $key
     * @param  mixed   $default
     * @return mixed
     */
    public static function get($array, $key, $default = null)
    {
        if (! static::accessible($array)) {
            return value($default);
        }

        if (is_null($key)) {
            return $array;
        }

        if (static::exists($array, $key)) {
            return $array[$key];
        }

        if (strpos($key, '.') === false) {
            return $array[$key] ?? value($default);
        }

        foreach (explode('.', $key) as $segment) {
            if (static::accessible($array) && static::exists($array, $segment)) {
                $array = $array[$segment];
            } else {
                return value($default);
            }
        }

        return $array;
    }

    /**
     * Check if an item or items exist in an array using "dot" notation.
     *
     * @param  \ArrayAccess|array  $array
     * @param  string|array  $keys
     * @return bool
     */
    public static function has($array, $keys)
    {
        $keys = (array) $keys;

        if (! $array || $keys === []) {
            return false;
        }

        foreach ($keys as $key) {
            $subKeyArray = $array;

            if (static::exists($array, $key)) {
                continue;
            }

            foreach (explode('.', $key) as $segment) {
                if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
                    $subKeyArray = $subKeyArray[$segment];
                } else {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * Determines if an array is associative.
     *
     * An array is "associative" if it doesn't have sequential numerical keys beginning with zero.
     *
     * @param  array  $array
     * @return bool
     */
    public static function isAssoc(array $array)
    {
        $keys = array_keys($array);

        return array_keys($keys) !== $keys;
    }

    /**
     * Get a subset of the items from the given array.
     *
     * @param  array  $array
     * @param  array|string  $keys
     * @return array
     */
    public static function only($array, $keys)
    {
        return array_intersect_key($array, array_flip((array) $keys));
    }

    /**
     * Pluck an array of values from an array.
     *
     * @param  array  $array
     * @param  string|array  $value
     * @param  string|array|null  $key
     * @return array
     */
    public static function pluck($array, $value, $key = null)
    {
        $results = [];

        [$value, $key] = static::explodePluckParameters($value, $key);

        foreach ($array as $item) {
            $itemValue = data_get($item, $value);

            // If the key is "null", we will just append the value to the array and keep
            // looping. Otherwise we will key the array using the value of the key we
            // received from the developer. Then we'll return the final array form.
            if (is_null($key)) {
                $results[] = $itemValue;
            } else {
                $itemKey = data_get($item, $key);

                if (is_object($itemKey) && method_exists($itemKey, '__toString')) {
                    $itemKey = (string) $itemKey;
                }

                $results[$itemKey] = $itemValue;
            }
        }

        return $results;
    }

    /**
     * Explode the "value" and "key" arguments passed to "pluck".
     *
     * @param  string|array  $value
     * @param  string|array|null  $key
     * @return array
     */
    protected static function explodePluckParameters($value, $key)
    {
        $value = is_string($value) ? explode('.', $value) : $value;

        $key = is_null($key) || is_array($key) ? $key : explode('.', $key);

        return [$value, $key];
    }

    /**
     * Push an item onto the beginning of an array.
     *
     * @param  array  $array
     * @param  mixed  $value
     * @param  mixed  $key
     * @return array
     */
    public static function prepend($array, $value, $key = null)
    {
        if (is_null($key)) {
            array_unshift($array, $value);
        } else {
            $array = [$key => $value] + $array;
        }

        return $array;
    }

    /**
     * Get a value from the array, and remove it.
     *
     * @param  array   $array
     * @param  string  $key
     * @param  mixed   $default
     * @return mixed
     */
    public static function pull(&$array, $key, $default = null)
    {
        $value = static::get($array, $key, $default);

        static::forget($array, $key);

        return $value;
    }

    /**
     * Get one or a specified number of random values from an array.
     *
     * @param  array  $array
     * @param  int|null  $number
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    public static function random($array, $number = null)
    {
        $requested = is_null($number) ? 1 : $number;

        $count = count($array);

        if ($requested > $count) {
            throw new InvalidArgumentException(
                "You requested {$requested} items, but there are only {$count} items available."
            );
        }

        if (is_null($number)) {
            return $array[array_rand($array)];
        }

        if ((int) $number === 0) {
            return [];
        }

        $keys = array_rand($array, $number);

        $results = [];

        foreach ((array) $keys as $key) {
            $results[] = $array[$key];
        }

        return $results;
    }

    /**
     * Set an array item to a given value using "dot" notation.
     *
     * If no key is given to the method, the entire array will be replaced.
     *
     * @param  array   $array
     * @param  string  $key
     * @param  mixed   $value
     * @return array
     */
    public static function set(&$array, $key, $value)
    {
        if (is_null($key)) {
            return $array = $value;
        }

        $keys = explode('.', $key);

        while (count($keys) > 1) {
            $key = array_shift($keys);

            // If the key doesn't exist at this depth, we will just create an empty array
            // to hold the next value, allowing us to create the arrays to hold final
            // values at the correct depth. Then we'll keep digging into the array.
            if (! isset($array[$key]) || ! is_array($array[$key])) {
                $array[$key] = [];
            }

            $array = &$array[$key];
        }

        $array[array_shift($keys)] = $value;

        return $array;
    }

    /**
     * Shuffle the given array and return the result.
     *
     * @param  array  $array
     * @param  int|null  $seed
     * @return array
     */
    public static function shuffle($array, $seed = null)
    {
        if (is_null($seed)) {
            shuffle($array);
        } else {
            mt_srand($seed);
            shuffle($array);
            mt_srand();
        }

        return $array;
    }

    /**
     * Sort the array using the given callback or "dot" notation.
     *
     * @param  array  $array
     * @param  callable|string|null  $callback
     * @return array
     */
    public static function sort($array, $callback = null)
    {
        return Collection::make($array)->sortBy($callback)->all();
    }

    /**
     * Recursively sort an array by keys and values.
     *
     * @param  array  $array
     * @return array
     */
    public static function sortRecursive($array)
    {
        foreach ($array as &$value) {
            if (is_array($value)) {
                $value = static::sortRecursive($value);
            }
        }

        if (static::isAssoc($array)) {
            ksort($array);
        } else {
            sort($array);
        }

        return $array;
    }

    /**
     * Convert the array into a query string.
     *
     * @param  array  $array
     * @return string
     */
    public static function query($array)
    {
        return http_build_query($array, null, '&', PHP_QUERY_RFC3986);
    }

    /**
     * Filter the array using the given callback.
     *
     * @param  array  $array
     * @param  callable  $callback
     * @return array
     */
    public static function where($array, callable $callback)
    {
        return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
    }

    /**
     * If the given value is not an array and not null, wrap it in one.
     *
     * @param  mixed  $value
     * @return array
     */
    public static function wrap($value)
    {
        if (is_null($value)) {
            return [];
        }

        return is_array($value) ? $value : [$value];
    }
}

Anon7 - 2022
AnonSec Team