Will return argument at index given
@param $num
@return mixed
496311
public function getArg($num)
    {
        return isset($this->args[$num]) ? $this->args[$num] : null;
    }
1264437
private function page($num)
    {
        if ($num == 1) {
            return $this->page->url('delete', $this->url, $this->get);
        }

        return $this->page->url('add', $this->url, $this->get, $num.'of'.$this->total);
    }
430998
protected function toWords($num)
    {
        $neg = 0;
        $ret = [];

        /**
         * Negative ?
         */
        if ($num < 0) {
            $ret[] = $this->minus;
            $num = -$num;
            $neg = 1;
        }

        /**
         * Removes leading zeros, spaces, decimals etc.
         * Adds thousands separator.
         */
        $num = number_format($num, 0, '.', '.');

        /**
         * Testing Zero
         */
        if ($num == 0) {
            return 'zero';
        }

        /**
         * Breaks into chunks of 3 digits.
         * Reversing array to process from right to left.
         */
        $chunks = array_reverse(explode(".", $num));

        /**
         * Looping through the chunks
         */
        foreach ($chunks as $index => $chunk) {
            /**
             * Testing Range
             */
            if (!array_key_exists($index, self::$exponent)) {
                throw new NumberToWordsException('Number out of range.');
            }

            /**
             * Testing Zero
             */
            if ($chunk == 0) {
                continue;
            }

            /**
             * Testing plural of exponent
             */
            if ($chunk > 1) {
                $exponent = str_replace('ão', 'ões', self::$exponent[$index]);
            } else {
                $exponent = self::$exponent[$index];
            }

            /**
             * Adding exponent
             */
            $ret[] = $exponent;

            /**
             * Actual Number
             */
            $word = array_filter($this->parseChunk($chunk));
            $ret[] = implode($this->separator, $word);
        }

        /**
         * In Brazilian Portuguese the last chunck must be separated under
         * special conditions.
         */
        if ((count($ret) > 2 + $neg)
            && $this->mustSeparate($chunks)
        ) {
            $ret[1 + $neg] = trim($this->separator . $ret[1 + $neg]);
        }

        $ret = array_reverse(array_filter($ret));

        return implode(' ', $ret);
    }
385823
private function get_original_string($num) {
        $length = $this->table_originals[$num * 2 + 1];
        $offset = $this->table_originals[$num * 2 + 2];
        if (!$length)
            return '';
        fseek($this->STREAM, $offset);
        $data = fread($this->STREAM, $length);
        return (string)$data;
    }
685398
private static function _validateNumber($num): bool
    {
        if (is_int($num)) {
            return true;
        }
        if (is_string($num) && preg_match('/-?\d+/', $num)) {
            return true;
        }
        return false;
    }
141055
public function getCall($num)
    {
        if (array_key_exists($num, $this->calls)) {

            return $this->calls[$num];
        }

        return null;
    }
485428
public static function get($index = null, $default = null)
	{
		return (func_num_args() === 0) ? $_GET : \Arr::get($_GET, $index, $default);
	}
132169
public static function getIsSet($param)
    {
        $blnReturn = (isset($_REQUEST[$param]));

        if (!$blnReturn) {
            //*** Try PUT or DELETE.
            $strPutValue = static::getHttpBodyValue($param);

            $blnReturn = (!is_null($strPutValue));
        }

        return $blnReturn;
    }
449339
public function getArg($arg_num, $default_val = null)
    {
        if (isset($this->args[$arg_num])) {
            return $this->args[$arg_num];
        }

        return $default_val;
    }
729202
static public function numberToRoman($num) 
    {
        // Make sure that we only use the integer portion of the value
        $numr = intval($num);
        $result = '';

        // Declare a lookup array that we will use to traverse the number:
        $lookup = array('M' => 1000, 'CM' => 900, 'D' => 500, 'CD' => 400, 'C' => 100, 'XC' => 90, 'L' => 50, 'XL' => 40, 'X' => 10, 'IX' => 9, 'V' => 5, 'IV' => 4, 'I' => 1);

        foreach($lookup as $roman => $value) {
            // Determine the number of matches
            $matches = intval($numr / $value);

            // Store that many characters
            $result .= str_repeat($roman, $matches);

            // Substract that from the number
            $numr = $numr % $value;
        }

        // The Roman numeral should be built, return it
        return (string)$result;
    }
1101009
public function getStatistics($index, $num)
    {
        $result = ProcessManager::getInstance()->getRpcCall(SDHelpProcess::class)->getStatistics($index, $num);
        return $result;
    }
1129396
private static function num2str(int $num):string
    {
        if ($num > 0 && $num < 160) {
            return chr($num);
        } elseif ($num < -20319 || $num > -10247) {
            return '';
        } else {
            $total = sizeof(self::$lib) - 1;
            for ($i = $total; $i >= 0; $i--) {
                if (self::$lib[$i][1] <= $num) {
                    break;
                }
            }
            return self::$lib[$i][0];
        }
    }
1023583
private function readAndHashBytes($num)
    {
        $bytes = $this->stream->read($num);
        hash_update($this->hashContext, $bytes);
        return $bytes;
    }
789646
public function ne($num) {
        if (!$this->_isValid) {
            return $this;
        }

        if ($this->_unsafeVar == $num) {
            $this->_isValid = false;
        }
        return $this;
    }
808010
public function withExplicitPolicy(int $num): self
    {
        $state = clone $this;
        $state->_explicitPolicy = $num;
        return $state;
    }
127387
protected static function getValue($param)
    {
        $data = explode(':', $param);

        $result = ['rule' => trim($data[0])];

        $result['value'] = count($data) > 1 ? $data[1] : null;

        return $result;
    }
732903
public function returnsArgument(int $index = 0): Stub
    {
        return $this->doesWith(
            function ($arguments) use ($index) {
                return $arguments->get($index);
            },
            [],
            false,
            true,
            false
        );
    }