stock GetTextFileLine(buffer[], file[], line, size = sizeof(buffer)) // by Luka P.
{
    new File:stream = fopen(file, io_read), index = -1;
    if(!stream) return 0;

    while(fread(stream, buffer, size))
        if(++index == line) break;

    return fclose(stream);
}

static stock GetKey(file[], buffer[], key[], len = sizeof(buffer)) // by Luka P.
{
    new File:stream = fopen(file, io_read), line = -1, index = 0;
    if(!stream) return 0;
    
    while(fread(stream, buffer, len))
    {
        ++line;
        if(strfind(buffer, key, true) == 0)
        {
            break;
        }
    }
    
    for(new x=0; x < len; ++x)
    {
        if(buffer[x] == '=')
        {
            index = x + 1;
        }
    }
    
    strdel(buffer, 0, index);
    return fclose(stream);
}

CMD:test(playerid,params[])
{
	if((sscanf(params, "s", params[1])) || (sscanf(params, "s", params[2]))) return SendClientMessage(playerid, ADMINRED, "(!)"HEX_WHITE" Usage is /Test <Something>");
	SendClientMessagef(playerid, ADMINRED, "(!)"HEX_WHITE" The first param is %s and the second one is %s.", GetParam(params, 1), GetParam(params, 2));
	return 1;
}

#define findNextPositive(%0,%1,%2) findNext(%0,%1,1,%2)
#define findNextNegative(%0,%1,%2) findNext(%0,%1,0,%2)

static stock findNext(const array[], index, type, len = sizeof(array))
{
    new _next = -1;
    for(new x = index + 1; x < len; ++x)
    {
        if((type) ? (array[x]) : (!array[x]))
        {
            _next = x;
            break;
        }
    }
    return _next;
}

stock TeleportPlayer(playerid, Float:X, Float:Y, Float:Z)
{
    if(GetPlayerState(playerid) == PLAYER_STATE_DRIVER)
    {
        new car = GetPlayerVehicleID(playerid);
        SetPlayerPos(playerid, X, Y, Z);
        SetVehiclePos(car, X, Y, Z);
        PutPlayerInVehicle(playerid, car, 0);
    }
    else
    {
        SetPlayerPos(playerid, X, Y, Z);
    }
    return 1;
}

stock StairsToHeaven(Float:X, Float:Y, Float:Z);
{
    new Z_Increase, Quant, Desired;
    Desired = 400; // We're creating 400 stairs!
    do
    {
        Z_Increase += 20;
        Quant += 1;
        CreateObject(18771, X, Y, Z+Z_Increase, 0, 0, 0, 250);
    }
    while (Desired != Quant);
    return 1;
}

Bench for swap with variable: executes, by average, 2536.06 times/ms.
Bench for swap with xor: executes, by average, 3052.78 times/ms.

stock getNumCountFromAlfabet(input[])
{
    switch(input[0])
    {
        case 'a', 'A': return 1;
        case 'b', 'B': return 2;
        case 'c', 'C': return 3;
        case 'd', 'D': return 4;
        case 'e', 'E': return 5;
        case 'f', 'F': return 6;
        case 'g', 'G': return 7;
        case 'h', 'H': return 8;
        case 'i', 'I': return 9;
        case 'j', 'J': return 10;
        case 'k', 'K': return 11;
        case 'l', 'L': return 12;
        case 'm', 'M': return 13;
        case 'n', 'N': return 14;
        case 'o', 'O': return 15;
        case 'p', 'P': return 16;
        case 'q', 'Q': return 17;
        case 'r', 'R': return 18;
        case 's', 'S': return 19;
        case 't', 'T': return 20;
        case 'u', 'U': return 21;
        case 'v', 'V': return 22;
        case 'w', 'W': return 23;
        case 'x', 'X': return 24;
        case 'y', 'Y': return 25;
        case 'z', 'Z': return 26;
        default: return strval(input[0]);
    }
    return -1;
}

stock hash(input[])
{
    new tmp[2], tmppass[129];
    WP_Hash(tmppass, 129, input);
    for(new i = 0; i < strlen(tmppass); i++){
        switch(tmppass[i]){
            case 'a'..'z', 0..9:    tmp[0]  =   ((tmp[0] + getNumCountFromAlfabet(tmppass[i]) [CENSORED])) * getNumCountFromAlfabet(tmppass[i]);
            case 'A'..'Z':          tmp[0]  =   ((tmp[0] + getNumCountFromAlfabet(tmppass[i]) [CENSORED])) * (100 + getNumCountFromAlfabet(tmppass[i]));
        }
        tmp[1]                              =   ([CENSORED]);
    }
    return [CENSORED];
}

stock GetAlphabetIndex(const ch)
{
    return ('a' <= ch <= 'z') ? (ch - 96) : ('A' <= ch <= 'Z') ? (ch - 64) : '\0';
}

stock GetAlphabetIndex(const ch)
{
    if('a' <= ch <= 'z')
        return ch - 96;
    else if('A' <= ch <= 'Z')
        return ch - 64;
    else return '\0';
}

stock GetAlphabetIndex(const ch)
{
    switch(ch)
    {
        case 'a'..'z': return ch - 96;
        case 'A'..'Z': return ch - 64;
    }
    return '\0';
}