Gamezer V5 Physics

function sycf(s) // inicializa os parâmetros do jogo
{
    HDNL_DIS = 0;
    PROC_RD = 0;
    TFC = [];
    TFC.fd_w = 74000; // area width
    TFC.fd_h = 37000; // area height
    TFC.x_offs = 3000;
    TFC.y_offs = 3000;
    TFC.spf = 1;

    if (s == "sn")
    {
        TFC.spf = 1.4;
        TFC.upk = 1;
        TFC.pw_cn = 2980;
        TFC.pw_sd = 4260;
        TFC.pdtf = 400;
        TFC["or"] = 840; // raio da bola
        TFC.ei = 8;
        TFC.bi = 7;
        TFC.bnm = 22;
        TFC.whsm = 6;
    }
    else if (s == "cr")
    {
        TFC.spf = 1.1;
        TFC.upk = 0;
        TFC["or"] = 985; // raio da bola
        TFC.ei = 9;
        TFC.bi = 7;
        TFC.bnm = 3;
        TFC.whsm = 5;
    }
    else if (s == "ru")
    {
        TFC.spf = 1;
        TFC.upk = 1;
        TFC.pw_cn = 3000;
        TFC.pw_sd = 3300;
        TFC.pdtf = 400;
        TFC["or"] = 1000; // raio da bola
        TFC.ei = 8;
        TFC.bi = 7;
        TFC.bnm = 16;
        TFC.whsm = 5;
    }
    else if (s == "gz")
    {
        TFC.spf = 1.4;
        TFC.fd_w = 70000;
        TFC.fd_h = 35000;
        TFC.x_offs = 5000;
        TFC.y_offs = 4000;
        TFC.bnm = 16;
        TFC.upk = 1;
        TFC.pw_cn = 3600;
        TFC.pw_sd = 4610;
        TFC.pdtf = 800;
        TFC["or"] = 1000; // raio da bola
        TFC.ei = 8;
        TFC.bi = 7;
        TFC.whsm = 5;
    }
    else
    {
        if (s == "nb")
            TFC.bnm = 10;
        else
            TFC.bnm = 16;

        TFC.spf = 1.4;
        TFC.upk = 1;
        s = "am";
        TFC.pw_cn = 3380;
        TFC.pw_sd = 4020;
        TFC.pdtf = 800;
        TFC["or"] = 920; // raio da bola
        TFC.ei = 8;
        TFC.bi = 7;
        TFC.whsm = 5;
    }

    TFC.apr = s;
    TFC.pi_e_p = 15;
    TFC.pi_e_m = 5;
    TFC.vc = 2100;
    TFC.od = TFC["or"] * 2; // diâmetro da bola
    TFC.od2 = TFC.od * 2; // dobro do diâmetro da bola
    TFC.ow = TFC.od * TFC.od; // diâmetro da bola ao quadrado
    TFC.ou = TFC["or"] * TFC["or"]; // raio da bola ao quadrado
    TFC.ti = 3.141; // pi
    TFC.te = thma_i(TFC.ti / 180); // pi / 180
    TFC.a_n = TFC["or"] + TFC.x_offs; // left
    TFC.a_x = TFC.fd_w - TFC["or"] + TFC.x_offs; // right
    TFC.b_n = TFC["or"] + TFC.y_offs; // top
    TFC.b_x = TFC.fd_h - TFC["or"] + TFC.y_offs; // bottom
    TFC.a_ct = TFC.fd_w / 2 + TFC.x_offs; // coordenada x do centro da mesa
    TFC.b_ct = TFC.fd_h / 2 + TFC.y_offs; // coordenada y do centro da mesa
    var __reg10 = Math.round(TFC.fd_w / 4);
    TFC.pch_1 = TFC.x_offs + __reg10;
    TFC.pch_2 = TFC.x_offs + __reg10 * 3;

    if (TFC.upk)
    {
        var __reg2 = TFC.od * 14;
        var __reg6 = Math.round(thma_i(Math.sin(thma_r(TFC.te * 14))) * __reg2);
        var __reg8 = Math.round(Math.sqrt(Math.abs(__reg2 * __reg2 - __reg6 * __reg6)));
        var __reg1 = TFC["or"] / 2;
        __reg1 = __reg1 * __reg1;
        __reg1 = Math.round(Math.sqrt(Math.abs(__reg1 + __reg1)));
        var __reg3 = TFC.pw_cn / 2;
        __reg3 = __reg3 * __reg3;
        __reg3 = Math.round(Math.sqrt(Math.abs(__reg3 + __reg3)));
        var __reg5 = TFC["or"] / 2;
        __reg5 = __reg5 * __reg5;
        __reg5 = Math.round(Math.sqrt(Math.abs(__reg5 + __reg5)));
        var __reg9 = Math.round(TFC.pw_sd / 2);
        var __reg4 = 1000;
        TFC.k_1a = [TFC.x_offs, TFC.y_offs + __reg3];
        TFC.k_1ga = -22.5;
        TFC.k_1a_pt1 = [TFC.k_1a[0] - __reg2 + __reg1, TFC.k_1a[1] - __reg2 - __reg1];
        TFC.k_1a_pt2 = [TFC.k_1a[0] + __reg1, TFC.k_1a[1] - __reg1];
        TFC.k_1a_pt3 = [TFC.k_1a[0] + __reg1, TFC.k_1a[1] + __reg2];
        TFC.k_1b = [TFC.x_offs + __reg3, TFC.y_offs];
        TFC.k_1gb = 112.5;
        TFC.k_1b_pt1 = [TFC.k_1b[0] - __reg2 - __reg1, TFC.k_1b[1] - __reg2 + __reg1];
        TFC.k_1b_pt2 = [TFC.k_1b[0] - __reg1, TFC.k_1b[1] + __reg1];
        TFC.k_1b_pt3 = [TFC.k_1b[0] + __reg2, TFC.k_1b[1] + __reg1];
        TFC.k_1pkp = [TFC.x_offs, TFC.y_offs];
        TFC.k_1pkp_a = [TFC.k_1pkp[0] - TFC.od, TFC.k_1pkp[1] + TFC.od];
        TFC.k_1pkp_b = [TFC.k_1pkp[0] + TFC.od, TFC.k_1pkp[1] - TFC.od];
        TFC.k_1pkt = [TFC.k_1pkp[0] - __reg5, TFC.k_1pkp[1] - __reg5];
        TFC.k_1bottg = [TFC.x_offs + __reg4, TFC.y_offs + __reg4];
        TFC.k_2a = [TFC.a_ct - __reg9, TFC.y_offs];
        TFC.k_2ga = 52;
        TFC.k_2a_pt1 = [TFC.k_2a[0] + __reg6 + TFC["or"], TFC.k_2a[1] - __reg8];
        TFC.k_2a_pt2 = [TFC.k_2a[0] + TFC["or"], TFC.k_2a[1] + __reg1];
        TFC.k_2a_pt3 = [TFC.k_2a[0] - __reg2, TFC.k_2a[1] + __reg1];
        TFC.k_2b = [TFC.a_ct + __reg9, TFC.y_offs];
        TFC.k_2gb = 128;
        TFC.k_2b_pt1 = [TFC.k_2b[0] - __reg6 - TFC["or"], TFC.k_2b[1] - __reg8];
        TFC.k_2b_pt2 = [TFC.k_2b[0] - TFC["or"], TFC.k_2b[1] + __reg1];
        TFC.k_2b_pt3 = [TFC.k_2a[0] + __reg2, TFC.k_2a[1] + __reg1];
        TFC.k_2pkp = [TFC.a_ct, TFC.y_offs - TFC.pdtf];
        TFC.k_2pkp_a = [TFC.k_2pkp[0] - TFC.od2, TFC.k_2pkp[1]];
        TFC.k_2pkp_b = [TFC.k_2pkp[0] + TFC.od2, TFC.k_2pkp[1]];
        TFC.k_2pkt = [TFC.k_2pkp[0], TFC.k_2pkp[1] - TFC["or"]];
        TFC.k_2bottg = [TFC.a_ct, TFC.y_offs];
        TFC.k_3a = [TFC.fd_w + TFC.x_offs - __reg3, TFC.y_offs];
        TFC.k_3ga = 67.5;
        TFC.k_3a_pt1 = [TFC.k_3a[0] + __reg2 + __reg1, TFC.k_3a[1] - __reg2 + __reg1];
        TFC.k_3a_pt2 = [TFC.k_3a[0] + __reg1, TFC.k_3a[1] + __reg1];
        TFC.k_3a_pt3 = [TFC.k_3a[0] - __reg2, TFC.k_3a[1] + __reg1];
        TFC.k_3b = [TFC.fd_w + TFC.x_offs, TFC.y_offs + __reg3];
        TFC.k_3gb = -157.5;
        TFC.k_3b_pt1 = [TFC.k_3b[0] + __reg2 - __reg1, TFC.k_3b[1] - __reg2 - __reg1];
        TFC.k_3b_pt2 = [TFC.k_3b[0] - __reg1, TFC.k_3b[1] - __reg1];
        TFC.k_3b_pt3 = [TFC.k_3b[0] - __reg1, TFC.k_3b[1] + __reg2];
        TFC.k_3pkp = [TFC.fd_w + TFC.x_offs, TFC.y_offs];
        TFC.k_3pkp_a = [TFC.k_3pkp[0] - TFC.od, TFC.k_3pkp[1] - TFC.od];
        TFC.k_3pkp_b = [TFC.k_3pkp[0] + TFC.od, TFC.k_3pkp[1] + TFC.od];
        TFC.k_3pkt = [TFC.k_3pkp[0] + __reg5, TFC.k_3pkp[1] - __reg5];
        TFC.k_3bottg = [TFC.x_offs + TFC.fd_w - __reg4, TFC.y_offs + __reg4];
        TFC.k_4a = [TFC.x_offs, TFC.fd_h + TFC.y_offs - __reg3];
        TFC.k_4ga = 22.5;
        TFC.k_4a_pt1 = [TFC.k_4a[0] - __reg2 + __reg1, TFC.k_4a[1] + __reg2 + __reg1];
        TFC.k_4a_pt2 = [TFC.k_4a[0] + __reg1, TFC.k_4a[1] + __reg1];
        TFC.k_4a_pt3 = [TFC.k_4a[0] + __reg1, TFC.k_4a[1] - __reg2];
        TFC.k_4b = [TFC.x_offs + __reg3, TFC.fd_h + TFC.y_offs];
        TFC.k_4gb = -112.5;
        TFC.k_4b_pt1 = [TFC.k_4b[0] - __reg2 - __reg1, TFC.k_4b[1] + __reg2 - __reg1];
        TFC.k_4b_pt2 = [TFC.k_4b[0] - __reg1, TFC.k_4b[1] - __reg1];
        TFC.k_4b_pt3 = [TFC.k_4b[0] + __reg2, TFC.k_4b[1] - __reg1];
        TFC.k_4pkp = [TFC.x_offs, TFC.fd_h + TFC.y_offs];
        TFC.k_4pkp_a = [TFC.k_4pkp[0] - TFC.od, TFC.k_4pkp[1] - TFC.od];
        TFC.k_4pkp_b = [TFC.k_4pkp[0] + TFC.od, TFC.k_4pkp[1] + TFC.od];
        TFC.k_4pkt = [TFC.k_4pkp[0] - __reg5, TFC.k_4pkp[1] + __reg5];
        TFC.k_4bottg = [TFC.x_offs + __reg4, TFC.y_offs + TFC.fd_h - __reg4];
        TFC.k_5a = [TFC.a_ct - __reg9, TFC.fd_h + TFC.y_offs];
        TFC.k_5ga = -52;
        TFC.k_5a_pt1 = [TFC.k_5a[0] + __reg6 + TFC["or"], TFC.k_5a[1] + __reg8];
        TFC.k_5a_pt2 = [TFC.k_5a[0] + TFC["or"], TFC.k_5a[1] - __reg1];
        TFC.k_5a_pt3 = [TFC.k_5a[0] - __reg2, TFC.k_5a[1] - __reg1];
        TFC.k_5b = [TFC.a_ct + __reg9, TFC.fd_h + TFC.y_offs];
        TFC.k_5gb = -128;
        TFC.k_5b_pt1 = [TFC.k_5b[0] - __reg6 - TFC["or"], TFC.k_5b[1] + __reg8];
        TFC.k_5b_pt2 = [TFC.k_5b[0] - TFC["or"], TFC.k_5b[1] - __reg1];
        TFC.k_5b_pt3 = [TFC.k_5a[0] + __reg2, TFC.k_5a[1] - __reg1];
        TFC.k_5pkp = [TFC.a_ct, TFC.fd_h + TFC.y_offs + TFC.pdtf];
        TFC.k_5pkp_a = [TFC.k_5pkp[0] - TFC.od2, TFC.k_5pkp[1]];
        TFC.k_5pkp_b = [TFC.k_5pkp[0] + TFC.od2, TFC.k_5pkp[1]];
        TFC.k_5pkt = [TFC.k_5pkp[0], TFC.k_5pkp[1] + TFC["or"]];
        TFC.k_5bottg = [TFC.a_ct, TFC.fd_h + TFC.y_offs];
        TFC.k_6a = [TFC.fd_w + TFC.x_offs - __reg3, TFC.fd_h + TFC.y_offs];
        TFC.k_6ga = -67.5;
        TFC.k_6a_pt1 = [TFC.k_6a[0] + __reg2 + __reg1, TFC.k_6a[1] + __reg2 - __reg1];
        TFC.k_6a_pt2 = [TFC.k_6a[0] + __reg1, TFC.k_6a[1] - __reg1];
        TFC.k_6a_pt3 = [TFC.k_6a[0] - __reg2, TFC.k_6a[1] - __reg1];
        TFC.k_6b = [TFC.fd_w + TFC.x_offs, TFC.fd_h + TFC.y_offs - __reg3];
        TFC.k_6gb = 157.5;
        TFC.k_6b_pt1 = [TFC.k_6b[0] + __reg2 - __reg1, TFC.k_6b[1] + __reg2 + __reg1];
        TFC.k_6b_pt2 = [TFC.k_6b[0] - __reg1, TFC.k_6b[1] + __reg1];
        TFC.k_6b_pt3 = [TFC.k_6b[0] - __reg1, TFC.k_6b[1] - __reg2];
        TFC.k_6pkp = [TFC.fd_w + TFC.x_offs, TFC.fd_h + TFC.y_offs];
        TFC.k_6pkp_a = [TFC.k_6pkp[0] - TFC.od, TFC.k_6pkp[1] + TFC.od];
        TFC.k_6pkp_b = [TFC.k_6pkp[0] + TFC.od, TFC.k_6pkp[1] - TFC.od];
        TFC.k_6pkt = [TFC.k_6pkp[0] + __reg5, TFC.k_6pkp[1] + __reg5];
        TFC.k_6bottg = [TFC.x_offs + TFC.fd_w - __reg4, TFC.y_offs + TFC.fd_h - __reg4];
    }
}

function prpy(f) // inicializa a semente
{
    _root.println("prpy: " + f);
    TFC.sqb = [];
    TFC.sqk = _root.hmx(f);
    _root.println("sqk=" + TFC.sqk);
    TFC.sqc = [];

    var __reg2 = 0;
    var s = "";
    while (__reg2 < 32)
    {
        TFC.sqc[__reg2] = Math.round(parseInt(TFC.sqk.substr(__reg2, 1), 16));

        if (s == "")
            s = "" + TFC.sqc[__reg2];
        else
            s = s + ", " + TFC.sqc[__reg2];

        ++__reg2;
    }

    _root.println("sqc={" + s + "}");

    __reg2 = 0;
    for (;;)
    {
        if (__reg2 >= TFC.bnm)
            return;

        if (TFC.sqc[__reg2] % 2 == 0)
            TFC.sqb.push(__reg2);
        else
            TFC.sqb.unshift(__reg2);

        ++__reg2;
    }
}

function bordhit(c, np) // registra as colisões com as bordas
{
    if (TFC.apr != "cr" || c !== 0)
        return undefined;

    if (typeof SH_RTGC.ct == "object")
    {
        var __reg2 = SH_RTGC.ct.length;
        if (__reg2 > 1)
        {
            var __reg1 = 1;
            while (__reg1 < __reg2)
            {
                if (SH_RTGC.ct[0] != SH_RTGC.ct[__reg1])
                {
                    return undefined;
                }
                ++__reg1;
            }
        }

        if (typeof SH_RTGC.pk != "object")
            SH_RTGC.pk = [];


        if (SH_RTGC.pk.length <= 3)
            SH_RTGC.pk.push([np[0], np[1]]);
    }
}

function sound_bordkick(obj, s) // toca o som do efeito da colisão das bolas com as bordas
{
    var __reg1 = soundRat_bordkick * (s / 100);
    if (__reg1 > 100)
        __reg1 = 100;

    var __reg2 = new Sound(obj);
    __reg2.attachSound("snb_bordkick");
    __reg2.setVolume(__reg1);
    __reg2.start();
}

function sound_kick(obj, s) // toca o som da colisão entre bolas
{
    var __reg1 = soundRat_kick * (s / 100);
    if (__reg1 > 100)
        __reg1 = 100;

    var __reg2 = new Sound(obj);
    __reg2.attachSound("snb_kick");
    __reg2.setVolume(__reg1);
    __reg2.start();
}

function sound_keykick(obj, s) // toca o som do taco sendo atirado na bola
{
    var __reg1 = soundRat_keykick * (s / 100);
    if (__reg1 > 100)
        __reg1 = 100;

    var __reg2 = new Sound(obj);
    __reg2.attachSound("snb_keykick");
    __reg2.setVolume(__reg1);
    __reg2.start();
}

function sound_pocket(obj, s) // Toca o som das bolas sendo encaçapadas
{
    var __reg1 = soundRat_pocket * (s / 100);
    if (__reg1 > 100)
        __reg1 = 100;

    if (__reg1 < 20)
        __reg1 = 20;

    var __reg2 = new Sound(obj);
    __reg2.attachSound("snb_pocket");
    __reg2.setVolume(__reg1);
    __reg2.start();
}

function whs(obj, f) // Define o estado de rotação das bolas
{
    if (obj.wheel != undefined)
    {
        var __reg1 = obj.wheel._currentframe + Math.round(f / 100 * TFC.whsm);
        if (__reg1 > 200)
            __reg1 = __reg1 - 200;
        else if (__reg1 < -200)
            __reg1 = 1;
        else if (__reg1 < 1)
            __reg1 = 200 + __reg1;

        obj.wheel.gotoAndStop(__reg1);
    }
}

function thmj(v1_1a, v1_1b, v1_2a, v1_2b, v2_1a, v2_1b, v2_2a, v2_2b) // Obtém o ponto de intersecção entre dois segmentos de reta
{
    var det = (v1_1a - v1_2a) * (v2_2b - v2_1b) - (v1_1b - v1_2b) * (v2_2a - v2_1a);
    var T_A = (v1_1a - v2_1a) * (v2_2b - v2_1b) - (v1_1b - v2_1b) * (v2_2a - v2_1a);
    var T_B = (v1_1a - v1_2a) * (v1_1b - v2_1b) - (v1_1b - v1_2b) * (v1_1a - v2_1a);

    if (Math.abs(det) < 0.000001)
        return [0]; // retorna [0] se a intersecção for vazia devido aos dois segmentos serem paralelos

    var ta = T_A / det;
    var tb = T_B / det;

    if (0 <= ta && ta <= 1 && 0 <= tb && tb <= 1)
        return [1, ta, tb]; // retorna [1, ta, tb] se a intersecção for não vazia onde ta e tb são as coordenadas do ponto de intersecção

    return [-1]; // retorna [-1] se a intersecçao for vazia devido aos dois segmentos não forem paralelos, porém ainda assim não se cruzam
}

function thfr(c, a, s) // Adiciona dois vetores dados em coordenadas polares, o primeiro é o vetor posição da bola de índice c e o segundo é dado pelo comprimento s e ângulo a
{
    var cv = LFSET[c].v;
    var cs = LFSET[c].s;

    var csy = Math.round(thma_i(Math.sin(thma_r(TFC.te * cv))) * cs);
    var sy = Math.round(thma_i(Math.sin(thma_r(TFC.te * a))) * s);
    var csx = Math.round(Math.sqrt(Math.abs(cs * cs - csy * csy)));
    var sx = Math.round(Math.sqrt(Math.abs(s * s - sy * sy)));

    if (Math.abs(cv) > 90)
        csx = 0 - csx;

    if (Math.abs(a) > 90)
        sx = 0 - sx;

    var x = Math.round(csx + sx);
    var y = Math.round(csy + sy);
    LFSET[c].v = thmg(0, 0, x, y);
    LFSET[c].s = thmd(0, 0, x, y);
}

function thmp(a, b, c, d) // Adiciona dois vetores onde o primeiro é dado em coordenadas retangulares (a, b) (usualmente o vetor posição) e o segundo em coordenadas polares (d, c) (usualmente o vetor velocidade) e retorna o resultado em coordenadas retangulares
{
    var y = Math.round(thma_i(Math.sin(thma_r(TFC.te * c))) * d);
    var x = Math.round(Math.sqrt(Math.abs(d * d - y * y)));
    if (Math.abs(c) > 90)
        x = 0 - x;

    return [a + x, b + y];
}

function thmd(a, b, c, d) // Distância entre dois vetores
{
    var dx = Math.round(a - c);
    var dy = Math.round(b - d);
    return Math.round(Math.sqrt(Math.abs(dx * dx + dy * dy)));
}

function thmg(a, b, ar, br) // Ângulo entre dois vetores
{
    var __reg2 = Math.round(ar - a);
    var __reg1 = Math.round(br - b);
    var angle = thma_r(Math.atan2(__reg1, __reg2));
    return thmn(angle / TFC.te);
}

function dist_vec_to_line(x0, y0, x1, y1, x2, y2) // Distância entre um vetor e uma reta
{
    var A = y1 - y2;
    var B = x2 - x1;
    var C = x1 * y2 - x2 * y1;
    var D = Math.sqrt(Math.abs(A * A + B * B));
    if (D < 0.000001)
        return 0;

    return Math.round(Math.abs(A * x0 + B * y0 + C) / D);
}

function thmn(a) // Normaliza um ângulo que esteja no intervalo [0, 360] para o intervalo [-180, 180]
{
    if (a > 180)
        a = a - 360;


    if (a < -180)
        a = a + 360;


    return thma_d(a);
}

function thma_i(a) // Arredonda um número para 6 casas decimais
{
    return Math.round(a * 1000000) / 1000000;
}

function thma_r(a) // Arredonda um número para 4 casas decimais
{
    return Math.round(a * 10000) / 10000;
}

function thma_d(a) // Arredonda um número para 2 casas decimais
{
    return Math.round(a * 100) / 100;
}

function gfcl(c, np, pkps, angRef)
{
    var s1 = TFC["or"] + LFSET[c].s; // raio da bola + módulo da bola
    var d = thmd(LFSET[c].a, LFSET[c].b, pkps[0], pkps[1]); // distância entre o centro da bola e o vetor pkps
    if (d <= s1)
    {
        var a = thmg(LFSET[c].a, LFSET[c].b, pkps[0], pkps[1]); // ângulo entre o vetor posição da bola e o vetor pkps
        var d2 = thmd(np[0], np[1], pkps[0], pkps[1]); // distância entre np e pkps
        var da = Math.abs(thmn(LFSET[c].v - a)); // diferença entre o ângulo da bola e a
        var __reg10 = Math.abs(Math.round(d * thma_i(Math.sin(thma_r(TFC.te * da)))));
        var __reg9 = thmg(np[0], np[1], pkps[0], pkps[1]);
        var __reg11 = Math.abs(thmn(LFSET[c].v - __reg9));
        if ((d2 < TFC["or"] || __reg11 > 90) && __reg10 < TFC["or"] && da < 90)
            return [1, thmn(2 * angRef - 180 - LFSET[c].v)];
    }

    return [0];
}

function ipgt(c, n) // encaçapa a bola de índice c na caçapa de índice n
{
    var __reg2 = TFC["k_" + n + "pkt"];
    LFSET[c].h._visible = 0;
    LFSET[c].a = __reg2[0];
    LFSET[c].b = __reg2[1];
    thps(c);

    if (typeof SH_RTGC.pk != "object")
        SH_RTGC.pk = [];

    SH_RTGC.pk.push([c, n]);
}

function iphk(c, np, n) // testa se o seguimento de reta que une a bola de índice c as coordenadas np intersepta o canto de índice n
{
    var ip = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC["k_" + n + "pkp_a"][0], TFC["k_" + n + "pkp_a"][1], TFC["k_" + n + "pkp_b"][0], TFC["k_" + n + "pkp_b"][1]);
    if (ip[0] == 1)
        return 1;

    return 0;
}

function tgf_1(c, np)
{
    if (LFSET[c].v < -157.5 || LFSET[c].v > 112.5)
    {
        var __reg3 = gfcl(c, np, TFC.k_1a, TFC.k_1ga);
        if (__reg3[0])
            glob_v_pass = __reg3[1];
    }

    if (LFSET[c].v > -112.5 && LFSET[c].v < -22.5)
    {
        var __reg8 = gfcl(c, np, TFC.k_1b, TFC.k_1gb);
        if (__reg8[0])
            glob_v_pass = __reg8[1];
    }

    if (Math.abs(LFSET[c].v) == 135 || Math.abs(LFSET[c].v) == 45)
        LFSET[c].v = LFSET[c].v + 0.1;

    var __reg5;
    var __reg6;

    if (LFSET[c].v < -135 || LFSET[c].v > 45)
    {
        var __reg4 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_1a_pt1[0], TFC.k_1a_pt1[1], TFC.k_1a_pt2[0], TFC.k_1a_pt2[1]);
        if (__reg4[0] == 1)
        {
            __reg6 = -135;
            __reg5 = thma_r(__reg4[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    if (LFSET[c].v > -135 && LFSET[c].v < 45)
    {
        var __reg7 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_1b_pt1[0], TFC.k_1b_pt1[1], TFC.k_1b_pt2[0], TFC.k_1b_pt2[1]);
        if (__reg7[0] == 1)
        {
            __reg6 = -135;
            __reg5 = thma_r(__reg7[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    var __reg10 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_1a_pt2[0], TFC.k_1a_pt2[1], TFC.k_1a_pt3[0], TFC.k_1a_pt3[1]);
    if (__reg10[0] == 1)
        return [0, np, 0, "l"];

    var __reg9 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_1b_pt2[0], TFC.k_1b_pt2[1], TFC.k_1b_pt3[0], TFC.k_1b_pt3[1]);
    if (__reg9[0] == 1)
        return [0, np, 0, "t"];

    if (np[0] < TFC.k_1b[0])
    {
        if (np[1] < TFC.k_1a[1])
            return [1, np, 1];
    }

    return [0, np];
}

function tgf_2(c, np)
{
    if (LFSET[c].v < -83 && LFSET[c].v > -173)
    {
        var __reg3 = gfcl(c, np, TFC.k_2a, TFC.k_2ga);
        if (__reg3[0])
            glob_v_pass = __reg3[1];
    }

    if (LFSET[c].v > -97 && LFSET[c].v < -7)
    {
        var __reg8 = gfcl(c, np, TFC.k_2b, TFC.k_2gb);
        if (__reg8[0])
            glob_v_pass = __reg8[1];
    }

    if (Math.abs(LFSET[c].v) == 104 || Math.abs(LFSET[c].v) == 76)
        LFSET[c].v = LFSET[c].v + 0.1;

    var __reg5;
    var __reg6;

    if (LFSET[c].v < -76 || LFSET[c].v > 104)
    {
        var __reg4 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_2a_pt1[0], TFC.k_2a_pt1[1], TFC.k_2a_pt2[0], TFC.k_2a_pt2[1]);
        if (__reg4[0] == 1)
        {
            __reg6 = -76;
            __reg5 = thma_r(__reg4[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    if (LFSET[c].v > -104 && LFSET[c].v < 76)
    {
        var __reg7 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_2b_pt1[0], TFC.k_2b_pt1[1], TFC.k_2b_pt2[0], TFC.k_2b_pt2[1]);
        if (__reg7[0] == 1)
        {
            __reg6 = -104;
            __reg5 = thma_r(__reg7[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);
            delete (glob_v_pass);
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    var __reg10 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_2a_pt2[0], TFC.k_2a_pt2[1], TFC.k_2a_pt3[0], TFC.k_2a_pt3[1]);
    if (__reg10[0] == 1)
        return [0, np, 0, "t"];

    var __reg9 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_2b_pt2[0], TFC.k_2b_pt2[1], TFC.k_2b_pt3[0], TFC.k_2b_pt3[1]);
    if (__reg9[0] == 1)
        return [0, np, 0, "t"];

    if (np[0] > TFC.k_2a[0] && np[0] < TFC.k_2b[0])
        return [1, np, 1];

    return [0, np];
}

function tgf_3(c, np)
{
    if (LFSET[c].v < -67.5 && LFSET[c].v > -157.5)
    {
        var __reg3 = gfcl(c, np, TFC.k_3a, TFC.k_3ga);
        if (__reg3[0])
            glob_v_pass = __reg3[1];
    }

    if (LFSET[c].v > -22.5 && LFSET[c].v < 67.5)
    {
        var __reg8 = gfcl(c, np, TFC.k_3b, TFC.k_3gb);
        if (__reg8[0])
            glob_v_pass = __reg8[1];
    }

    if (Math.abs(LFSET[c].v) == 135 || Math.abs(LFSET[c].v) == 45)
        LFSET[c].v = LFSET[c].v + 0.1;

    var __reg5;
    var __reg6;

    if (LFSET[c].v < -45 || LFSET[c].v > 135)
    {
        var __reg4 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_3a_pt1[0], TFC.k_3a_pt1[1], TFC.k_3a_pt2[0], TFC.k_3a_pt2[1]);
        if (__reg4[0] == 1)
        {
            __reg6 = -45;
            __reg5 = thma_r(__reg4[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete (glob_v_pass);
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    if (LFSET[c].v > -45 && LFSET[c].v < 135)
    {
        var __reg7 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_3b_pt1[0], TFC.k_3b_pt1[1], TFC.k_3b_pt2[0], TFC.k_3b_pt2[1]);
        if (__reg7[0] == 1)
        {
            __reg6 = -45;
            __reg5 = thma_r(__reg7[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete (glob_v_pass);
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    var __reg10 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_3a_pt2[0], TFC.k_3a_pt2[1], TFC.k_3a_pt3[0], TFC.k_3a_pt3[1]);
    if (__reg10[0] == 1)
        return [0, np, 0, "t"];

    var __reg9 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_3b_pt2[0], TFC.k_3b_pt2[1], TFC.k_3b_pt3[0], TFC.k_3b_pt3[1]);
    if (__reg9[0] == 1)
        return [0, np, 0, "r"];

    if (np[0] > TFC.k_3a[0])
    {
        if (np[1] < TFC.k_3b[1])
            return [1, np, 1];
    }

    return [0, np];
}

function bgf_1(c, np)
{
    if (LFSET[c].v < -112.5 || LFSET[c].v > 157.5)
    {
        var __reg3 = gfcl(c, np, TFC.k_4a, TFC.k_4ga);
        if (__reg3[0])
            glob_v_pass = __reg3[1];
    }

    if (LFSET[c].v > 22.5 && LFSET[c].v < 112.5)
    {
        var __reg8 = gfcl(c, np, TFC.k_4b, TFC.k_4gb);
        if (__reg8[0])
            glob_v_pass = __reg8[1];
    }

    if (Math.abs(LFSET[c].v) == 135 || Math.abs(LFSET[c].v) == 45)
        LFSET[c].v = LFSET[c].v + 0.1;

    var __reg5;
    var __reg6;

    if (LFSET[c].v < -45 || LFSET[c].v > 135)
    {
        var __reg4 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_4a_pt1[0], TFC.k_4a_pt1[1], TFC.k_4a_pt2[0], TFC.k_4a_pt2[1]);
        if (__reg4[0] == 1)
        {
            __reg6 = 135;
            __reg5 = thma_r(__reg4[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    if (LFSET[c].v > -45 && LFSET[c].v < 135)
    {
        var __reg7 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_4b_pt1[0], TFC.k_4b_pt1[1], TFC.k_4b_pt2[0], TFC.k_4b_pt2[1]);
        if (__reg7[0] == 1)
        {
            __reg6 = 135;
            __reg5 = thma_r(__reg7[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    var __reg10 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_4a_pt2[0], TFC.k_4a_pt2[1], TFC.k_4a_pt3[0], TFC.k_4a_pt3[1]);
    if (__reg10[0] == 1)
        return [0, np, 0, "l"];

    var __reg9 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_4b_pt2[0], TFC.k_4b_pt2[1], TFC.k_4b_pt3[0], TFC.k_4b_pt3[1]);
    if (__reg9[0] == 1)
        return [0, np, 0, "b"];

    if (np[0] < TFC.k_4b[0])
    {
        if (np[1] > TFC.k_4a[1])
            return [1, np, 1];
    }

    return [0, np];
}

function bgf_2(c, np)
{
    if (LFSET[c].v < 173 && LFSET[c].v > 83)
    {
        var __reg3 = gfcl(c, np, TFC.k_5a, TFC.k_5ga);
        if (__reg3[0])
            glob_v_pass = __reg3[1];
    }

    if (LFSET[c].v > 7 && LFSET[c].v < 97)
    {
        var __reg8 = gfcl(c, np, TFC.k_5b, TFC.k_5gb);
        if (__reg8[0])
            glob_v_pass = __reg8[1];
    }

    if (Math.abs(LFSET[c].v) == 104 || Math.abs(LFSET[c].v) == 76)
        LFSET[c].v = LFSET[c].v + 0.1;

    var __reg5;
    var __reg6;

    if (LFSET[c].v < -104 || LFSET[c].v > 76)
    {
        var __reg4 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_5a_pt1[0], TFC.k_5a_pt1[1], TFC.k_5a_pt2[0], TFC.k_5a_pt2[1]);
        if (__reg4[0] == 1)
        {
            __reg6 = 76;
            __reg5 = thma_r(__reg4[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    if (LFSET[c].v > -76 && LFSET[c].v < 104)
    {
        var __reg7 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_5b_pt1[0], TFC.k_5b_pt1[1], TFC.k_5b_pt2[0], TFC.k_5b_pt2[1]);
        if (__reg7[0] == 1)
        {
            __reg6 = 104;
            __reg5 = thma_r(__reg7[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    var __reg10 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_5a_pt2[0], TFC.k_5a_pt2[1], TFC.k_5a_pt3[0], TFC.k_5a_pt3[1]);
    if (__reg10[0] == 1)
        return [0, np, 0, "b"];

    var __reg9 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_5b_pt2[0], TFC.k_5b_pt2[1], TFC.k_5b_pt3[0], TFC.k_5b_pt3[1]);
    if (__reg9[0] == 1)
        return [0, np, 0, "b"];

    if (np[0] > TFC.k_5a[0] && np[0] < TFC.k_5b[0])
        return [1, np, 1];

    return [0, np];
}

function bgf_3(c, np)
{
    if (LFSET[c].v < 157.5 && LFSET[c].v > 67.5)
    {
        var __reg3 = gfcl(c, np, TFC.k_6a, TFC.k_6ga);
        if (__reg3[0])
            glob_v_pass = __reg3[1];
    }

    if (LFSET[c].v > -67.5 && LFSET[c].v < 22.5)
    {
        var __reg8 = gfcl(c, np, TFC.k_6b, TFC.k_6gb);
        if (__reg8[0])
            glob_v_pass = __reg8[1];
    }

    if (Math.abs(LFSET[c].v) == 135 || Math.abs(LFSET[c].v) == 45)
        LFSET[c].v = LFSET[c].v + 0.1;

    var __reg5;
    var __reg6;

    if (LFSET[c].v < -135 || LFSET[c].v > 45)
    {
        var __reg4 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_6a_pt1[0], TFC.k_6a_pt1[1], TFC.k_6a_pt2[0], TFC.k_6a_pt2[1]);
        if (__reg4[0] == 1)
        {
            __reg6 = 45;
            __reg5 = thma_r(__reg4[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    if (LFSET[c].v > -135 && LFSET[c].v < 45)
    {
        var __reg7 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_6b_pt1[0], TFC.k_6b_pt1[1], TFC.k_6b_pt2[0], TFC.k_6b_pt2[1]);
        if (__reg7[0] == 1)
        {
            __reg6 = 45;
            __reg5 = thma_r(__reg7[1] - 0.1) * LFSET[c].s;
            if (__reg5 <= 0)
            {
                np[0] = LFSET[c].a;
                np[1] = LFSET[c].b;
            }
            else
                np = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, __reg5);

            delete glob_v_pass;
            LFSET[c].v = thmn((LFSET[c].v - __reg6) * -1 + __reg6);

            return [1, np];
        }
    }

    var __reg10 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_6a_pt2[0], TFC.k_6a_pt2[1], TFC.k_6a_pt3[0], TFC.k_6a_pt3[1]);
    if (__reg10[0] == 1)
        return [0, np, 0, "b"];

    var __reg9 = thmj(LFSET[c].a, LFSET[c].b, np[0], np[1], TFC.k_6b_pt2[0], TFC.k_6b_pt2[1], TFC.k_6b_pt3[0], TFC.k_6b_pt3[1]);
    if (__reg9[0] == 1)
        return [0, np, 0, "r"];

    if (np[0] > TFC.k_6a[0])
    {
        if (np[1] > TFC.k_6b[1])
            return [1, np, 1];
    }

    return [0, np];
}

function thfw(c, blbr)
{
    if (LFSET[c].r_hs > 0)
    {
        if (blbr)
        {
            var s2 = Math.round(LFSET[c].s / 2); // metade do módulo da bola
            if (s2 < 0)
                s2 = 0;

            thfr(c, LFSET[c].r_hv, LFSET[c].r_hs); // adiciona o vetor posição da bola (em coordenadas polares) com o vetor (r_hv, r_hs) dado em coordenadas polares
            LFSET[c].s = LFSET[c].s - s2;

            if (LFSET[c].s < 2)
                LFSET[c].s = 2;
        }
        else
        {
            thfr(c, LFSET[c].r_hv, LFSET[c].r_hs);
            LFSET[c].s = Math.round(LFSET[c].s * 0.7);
        }

        LFSET[c].r_hs = 0;
    }
}

function thpc(c)
{
    if (!LFSET[c].e)
    {
        if (LFSET[c].c._visible)
        {
            var __reg23 = LFSET[c].c._alpha;
            __reg23 = __reg23 - 25;
            if (__reg23 <= 0)
            {
                LFSET[c].h._visible = 0;
                LFSET[c].c._visible = 0;
                LFSET[c].c._alpha = 100;
            }
            else
                LFSET[c].c._alpha = __reg23;
        }

        return 1;
    }

    delete glob_v_pass;

    if (LFSET[c].r_hs > 0)
        LFSET[c].r_hs = LFSET[c].r_hs - TFC.pi_e_p;

    if (LFSET[c].ri_v > 0)
    {
        LFSET[c].ri_v = LFSET[c].ri_v - 10;
        if (LFSET[c].ri_v < 0)
            LFSET[c].ri_v = 0;
    }
    else if (LFSET[c].ri_v < 0)
    {
        LFSET[c].ri_v = LFSET[c].ri_v + 10;
        if (LFSET[c].ri_v > 0)
            LFSET[c].ri_v = 0;
    }

    if (LFSET[c].ri_h > 0)
    {
        LFSET[c].ri_h = LFSET[c].ri_h - 5;
        if (LFSET[c].ri_h < 0)
            LFSET[c].ri_h = 0;
    }
    else if (LFSET[c].ri_h < 0)
    {
        LFSET[c].ri_h = LFSET[c].ri_h + 5;
        if (LFSET[c].ri_h > 0)
            LFSET[c].ri_h = 0;
    }

    if (LFSET[c].r_ms > 0)
    {
        LFSET[c].r_ms = LFSET[c].r_ms - TFC.pi_e_m;
        thfr(c, LFSET[c].r_mv, LFSET[c].r_ms);
    }

    LFSET[c].v = thmn(LFSET[c].v);
    LFSET[c].s = Math.round(LFSET[c].s - TFC.ei);
    if (LFSET[c].s < 1)
    {
        LFSET[c].s = 0;
        var __reg24 = 1;
        if (Math.abs(LFSET[c].ri_v) > 0)
        {
            whs(LFSET[c].c, LFSET[c].ri_v);
            __reg24 = 0;
        }

        if (Math.abs(LFSET[c].ri_h) > 0)
        {
            LFSET[c].c.wheel._rotation = thmn(LFSET[c].c.wheel._rotation + LFSET[c].ri_h / 20);
            __reg24 = 0;
        }

        return __reg24;
    }
    else if (LFSET[c].s > TFC.vc)
        LFSET[c].s = TFC.vc;

    var ods = TFC.od + LFSET[c].s; // diâmetro da bola + módulo do vetor velocidade
    var vec = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, LFSET[c].s); // adiciona a posição atual da bola ao seu vetor velocidade

    ltBKD = []; // collision data
    ltBKD.u = -1; // collision ball index
    ltBKD.n = 9999999; // collision ball velocity modulus
    ltBKD.al = 0; // collision ball velocity angle

    // faz a checagem de colisão com todas as demais bolas
    var idx = 0;
    while (idx < TFC.bnm)
    {
        if (idx != c) // verifica se a bola a ser verificada não é a mesma que esta sendo usada como teste de prova
        {
            if (LFSET[idx].e) // verifica se a bola a ser verificada está na mesa
            {
                var d = thmd(LFSET[c].a, LFSET[c].b, LFSET[idx].a, LFSET[idx].b); // calcula a distância entre a bola de prova e a bola que está sendo testada
                if (d <= ods)
                {
                    var tetha = thmg(LFSET[c].a, LFSET[c].b, LFSET[idx].a, LFSET[idx].b); // calcula a o ângulo entre a bola de prova e a bola que está sendo verificada
                    var d2 = thmd(vec[0], vec[1], LFSET[idx].a, LFSET[idx].b);
                    var dt = Math.abs(thmn(LFSET[c].v - tetha));
                    var dy = Math.abs(Math.round(d * thma_i(Math.sin(thma_r(TFC.te * dt)))));
                    var tetha2 = thmg(vec[0], vec[1], LFSET[idx].a, LFSET[idx].b);
                    var dt2 = Math.abs(thmn(LFSET[c].v - tetha2));
                    if ((d2 < TFC.od || dt2 > 90) && dy < TFC.od && dt < 90)
                    {
                        var dy2 = dy * dy;
                        var dx_1 = Math.round(Math.sqrt(Math.abs(d * d - dy2)));
                        var dx_2 = Math.round(Math.sqrt(Math.abs(TFC.ow - dy2)));
                        var dxx = dx_1 - dx_2;
                        if (dxx <= 0)
                        {
                            LFSET[idx].s = Math.round(LFSET[c].s / 2);
                            ltBKD.u = idx;
                            ltBKD.n = 0;
                            ltBKD.al = tetha;
                            break;
                        }

                        if (dxx < ltBKD.n)
                        {
                            ltBKD.u = idx;
                            ltBKD.n = dxx;
                            ltBKD.al = tetha;
                        }
                    }
                }
            }
        }

        ++idx;
    }

    if (ltBKD.u >= 0) // se ouve colisão
    {
        var u = ltBKD.u;
        if (SH_RTGC.t == c) // se a bola de teste for a cue ball
        {
            if (typeof SH_RTGC.ct != "object")
                SH_RTGC.ct = [];

            SH_RTGC.ct.push(u); // adiciona a bola colidida a lista de bolas colididas pela cue ball
        }
        else if (SH_RTGC.t == u) // caso contrário, se a bola colidida for a cue ball
        {
            if (typeof SH_RTGC.ct != "object")
                SH_RTGC.ct = [];

            SH_RTGC.ct.push(c); // adiciona a bola de teste a lista de bolas colididas pela cue ball
        }

        sound_kick(LFSET[c].c, LFSET[c].s);
        if (ltBKD.n > 0)
            vec = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, ltBKD.n);
        else
            vec = [LFSET[c].a, LFSET[c].b];

        var cval = thmn(LFSET[c].v - ltBKD.al);
        var angle;

        // calcula o ângulo em relação ao ângulo inicial que a bola de teste terá após a colisão, este ângulo devera ser 90 ou -90 graus dependendo de qual direção a bola de teste veio
        if (cval < 0)
            angle = -90;
        else
            angle = 90;

        var cvalangle = thmn(cval - angle);
        var uval = thmn(LFSET[u].v - ltBKD.al);
        uval = thmn(uval - angle);
        var cs = LFSET[c].s;
        var us = LFSET[u].s;
        var dcsy = Math.round(thma_i(Math.sin(thma_r(TFC.te * cvalangle))) * cs);
        var cusy = Math.round(thma_i(Math.sin(thma_r(TFC.te * uval))) * us);
        var dcsx = Math.round(Math.sqrt(Math.abs(cs * cs - dcsy * dcsy)));
        var dusx = Math.round(Math.sqrt(Math.abs(us * us - cusy * cusy)));
        if (Math.abs(cvalangle) < 90)
            dcsx = 0 - dcsx;

        if (Math.abs(uval) < 90)
            dusx = 0 - dusx;

        var dcusy = Math.round((dcsy + cusy - (dcsy - cusy)) * 0.5);
        var ducsy = Math.round((dcsy + cusy - (cusy - dcsy)) * 0.5);
        var dcusx = Math.round(Math.sqrt(Math.abs(dcsx * dcsx + dcusy * dcusy)));
        var ducsx = Math.round(Math.sqrt(Math.abs(dusx * dusx + ducsy * ducsy)));
        var dcusv = thmn(thmg(0, 0, dcusy, dcsx) + 90);
        var ducsa = thmn(thmg(0, 0, ducsy, dusx) + 90);
        var dcusval = thmn(dcusv + ltBKD.al);
        dcusval = thmn(dcusval + angle);
        var ducsaal = thmn(ducsa + ltBKD.al);
        ducsaal = thmn(ducsaal + angle);
        LFSET[u].v = ducsaal;
        LFSET[u].s = ducsx;
        LFSET[c].v = dcusval;
        LFSET[c].s = dcusx;
        thfw(c, 1);
        thfw(u, 1);
    }

    var __reg14 = [];
    var __reg15 = 0;
    var __reg17 = 0;
    if (TFC.upk)
    {
        if (vec[1] < TFC.b_ct)
        {
            if (vec[0] < TFC.pch_1)
            {
                __reg14 = tgf_1(c, vec);
                vec = __reg14[1];
                __reg17 = __reg14[0];
                __reg15 = 1;
            }
            else if (vec[0] < TFC.pch_2)
            {
                __reg14 = tgf_2(c, vec);
                vec = __reg14[1];
                __reg17 = __reg14[0];
                __reg15 = 2;
            }
            else
            {
                __reg14 = tgf_3(c, vec);
                vec = __reg14[1];
                __reg17 = __reg14[0];
                __reg15 = 3;
            }
        }
        else if (vec[0] < TFC.pch_1)
        {
            __reg14 = bgf_1(c, vec);
            vec = __reg14[1];
            __reg17 = __reg14[0];
            __reg15 = 4;
        }
        else if (vec[0] < TFC.pch_2)
        {
            __reg14 = bgf_2(c, vec);
            vec = __reg14[1];
            __reg17 = __reg14[0];
            __reg15 = 5;
        }
        else
        {
            __reg14 = bgf_3(c, vec);
            vec = __reg14[1];
            __reg17 = __reg14[0];
            __reg15 = 6;
        }
    }

    var __reg32;
    var __reg38;
    var __reg39;
    var __reg44;

    if (__reg17 == 1)
    {
        if (__reg14[2] !== 1)
        {
            thfw(c, 0);
            sound_bordkick(LFSET[c].c, LFSET[c].s);
            bordhit(c, vec);
        }
    }
    else
    {
        if (vec[0] < TFC.a_n && Math.abs(LFSET[c].v) > 90 && (__reg14[3] == undefined || __reg14[3] == "l"))
        {
            sound_bordkick(LFSET[c].c, LFSET[c].s);
            bordhit(c, vec);
            __reg44 = 180 - Math.abs(LFSET[c].v);
            __reg32 = TFC.a_n - vec[0];
            __reg38 = Math.round(__reg32 * thma_i(Math.tan(thma_r(TFC.te * __reg44))));
            __reg39 = Math.round(Math.sqrt(Math.abs(__reg32 * __reg32 + __reg38 * __reg38)));
            if (__reg39 > LFSET[c].s)
            {
                vec = [LFSET[c].a, LFSET[c].b];
            }
            else
            {
                vec = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, LFSET[c].s - __reg39);
            }

            if (glob_v_pass == undefined)
            {
                LFSET[c].v = thmn(180 - LFSET[c].v);
                LFSET[c].s = LFSET[c].s - TFC.bi;
            }
            else
            {
                LFSET[c].v = glob_v_pass;
                delete (glob_v_pass);
            }

            thfw(c, 0);
        }

        if (vec[0] > TFC.a_x && Math.abs(LFSET[c].v) < 90 && (__reg14[3] == undefined || __reg14[3] == "r"))
        {
            sound_bordkick(LFSET[c].c, LFSET[c].s);
            bordhit(c, vec);
            __reg44 = Math.abs(LFSET[c].v);
            __reg32 = vec[0] - TFC.a_x;
            __reg38 = Math.round(__reg32 * thma_i(Math.tan(thma_r(TFC.te * __reg44))));
            __reg39 = Math.round(Math.sqrt(Math.abs(__reg32 * __reg32 + __reg38 * __reg38)));
            if (__reg39 > LFSET[c].s)
                vec = [LFSET[c].a, LFSET[c].b];
            else
                vec = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, LFSET[c].s - __reg39);

            if (glob_v_pass == undefined)
            {
                LFSET[c].v = thmn(180 - LFSET[c].v);
                LFSET[c].s = LFSET[c].s - TFC.bi;
            }
            else
            {
                LFSET[c].v = glob_v_pass;
                delete glob_v_pass;
            }

            thfw(c, 0);
        }

        if (vec[1] < TFC.b_n && LFSET[c].v < 0 && (__reg14[3] == undefined || __reg14[3] == "t"))
        {
            sound_bordkick(LFSET[c].c, LFSET[c].s);
            bordhit(c, vec);
            __reg44 = Math.abs(Math.abs(LFSET[c].v) - 90);
            __reg32 = TFC.b_n - vec[1];
            __reg38 = Math.round(__reg32 * thma_i(Math.tan(thma_r(TFC.te * __reg44))));
            __reg39 = Math.round(Math.sqrt(Math.abs(__reg32 * __reg32 + __reg38 * __reg38)));
            if (__reg39 > LFSET[c].s)
                vec = [LFSET[c].a, LFSET[c].b];
            else
                vec = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, LFSET[c].s - __reg39);

            if (glob_v_pass == undefined)
            {
                LFSET[c].v = 0 - LFSET[c].v;
                LFSET[c].s = LFSET[c].s - TFC.bi;
            }
            else
            {
                LFSET[c].v = glob_v_pass;
                delete (glob_v_pass);
            }

            thfw(c, 0);
        }

        if (vec[1] > TFC.b_x && LFSET[c].v > 0 && (__reg14[3] == undefined || __reg14[3] == "b"))
        {
            sound_bordkick(LFSET[c].c, LFSET[c].s);
            bordhit(c, vec);
            __reg44 = Math.abs(Math.abs(LFSET[c].v) - 90);
            __reg32 = vec[1] - TFC.b_x;
            __reg38 = Math.round(__reg32 * thma_i(Math.tan(thma_r(TFC.te * __reg44))));
            __reg39 = Math.round(Math.sqrt(Math.abs(__reg32 * __reg32 + __reg38 * __reg38)));
            if (__reg39 > LFSET[c].s)
                vec = [LFSET[c].a, LFSET[c].b];
            else
                vec = thmp(LFSET[c].a, LFSET[c].b, LFSET[c].v, LFSET[c].s - __reg39);

            if (glob_v_pass == undefined)
            {
                LFSET[c].v = 0 - LFSET[c].v;
                LFSET[c].s = LFSET[c].s - TFC.bi;
            }
            else
            {
                LFSET[c].v = glob_v_pass;
                delete (glob_v_pass);
            }

            thfw(c, 0);
        }
    }

    if (glob_v_pass != undefined)
    {
        LFSET[c].v = glob_v_pass;
        delete (glob_v_pass);
    }

    if (__reg15 > 0)
    {
        if (iphk(c, vec, __reg15)) // testa se a bola foi encaçapada
        {
            sound_pocket(LFSET[c].c, LFSET[c].s);
            ipgt(c, __reg15);
            LFSET[c].e = 0;
            LFSET[c].s = 0;
            LFSET[c].v = 0;
            LFSET[c].r_mv = 0;
            LFSET[c].r_ms = 0;
            LFSET[c].r_hv = 0;
            LFSET[c].r_hs = 0;
            LFSET[c].ri_h = 0;
            LFSET[c].ri_v = 0;
            return 1;
        }
    }

    if (Math.abs(LFSET[c].ri_v) > LFSET[c].s / 1)
        whs(LFSET[c].c, LFSET[c].ri_v);
    else
    {
        whs(LFSET[c].c, LFSET[c].s);
        if (LFSET[c].rv != LFSET[c].v)
            LFSET[c].c.wheel._rotation = thmn(LFSET[c].v - 180);

        LFSET[c].rv = LFSET[c].v;
    }

    if (Math.abs(LFSET[c].ri_h) > 0)
    {
        LFSET[c].c.wheel._rotation = thmn(LFSET[c].c.wheel._rotation + LFSET[c].ri_h / 20);
    }

    LFSET[c].a = vec[0];
    LFSET[c].b = vec[1];
    thps(c);

    return 0;
}

function thps(c)
{
    LFSET[c].h._x = LFSET[c].c._x = LFSET[c].a / 100;
    LFSET[c].h._y = LFSET[c].c._y = LFSET[c].b / 100;
}

function abcht()
{
    LFSET = [];
    var __reg4 = 0;
    bst.removeMovieClip();
    ztable.removeMovieClip();
    this.createEmptyMovieClip("bst", 50);
    bst.attachMovie("deny_logo", "deny_logo", 799);
    bst.attachMovie("htgy", "htgy", 9);
    bst.createEmptyMovieClip("guide_sc", 2);
    bst.createEmptyMovieClip("guide_mask", 3);
    bst.createEmptyMovieClip("cue_mask", 4);
    this.attachMovie("ztable_" + TFC.apr, "ztable", 40);
    bst._x = bst._y = ztable._x = ztable._y = 0;
    bst._xscale = bst._yscale = ztable._xscale = ztable._yscale = 100;
    ztable.guide_switch._visible = GUIDE_ON;
    ztable.tbarea.onRelease =
        function ()
        {
        };
    ztable.tbarea.useHandCursor = false;
    bst.onEnterFrame =
        function ()
        {
            thrt();
        };
    bst.guide_mask.beginFill(0, 0);
    bst.guide_mask.moveTo(TFC.x_offs / 100, TFC.y_offs / 100);
    bst.guide_mask.lineTo(TFC.x_offs / 100 + TFC.fd_w / 100, TFC.y_offs / 100);
    bst.guide_mask.lineTo(TFC.x_offs / 100 + TFC.fd_w / 100, TFC.y_offs / 100 + TFC.fd_h / 100);
    bst.guide_mask.lineTo(TFC.x_offs / 100, TFC.y_offs / 100 + TFC.fd_h / 100);
    bst.guide_mask.lineTo(TFC.x_offs / 100, TFC.y_offs / 100);
    bst.guide_mask.endFill();
    bst.guide_sc.setMask(bst.guide_mask);
    bst.cue_mask.beginFill(0, 0);
    bst.cue_mask.moveTo(0, 0);
    bst.cue_mask.lineTo(800, 0);
    bst.cue_mask.lineTo(800, 430);
    bst.cue_mask.lineTo(0, 430);
    bst.cue_mask.lineTo(0, 0);
    bst.cue_mask.endFill();
    bst.deny_logo._visible = 0;
    bst.htgy._visible = 0;
    var __reg2 = 0;
    var __reg5;
    while (__reg2 < TFC.bnm)
    {
        if (TFC.apr == "sn" && __reg2 > 6)
            __reg4 = "r";
        else
            __reg4 = __reg2;

        var __reg3 = bst.attachMovie("ballshw_" + TFC.apr, "sh" + __reg2, 50 + __reg2);
        __reg5 = bst.attachMovie(TFC.apr + "_" + __reg4, "b" + __reg2, 100 + __reg2);
        __reg5.mi = __reg2;
        __reg5._x = __reg3._x = -500;
        __reg5._y = __reg3._y = -500;
        LFSET[__reg2] = [];
        LFSET[__reg2].h = __reg3;
        LFSET[__reg2].c = __reg5;
        LFSET[__reg2].e = 1;
        LFSET[__reg2].s = 0;
        LFSET[__reg2].v = 0;
        LFSET[__reg2].r_mv = 0;
        LFSET[__reg2].r_ms = 0;
        LFSET[__reg2].r_hv = 0;
        LFSET[__reg2].r_hs = 0;
        LFSET[__reg2].ri_h = 0;
        LFSET[__reg2].ri_v = 0;
        LFSET[__reg2].a = 0;
        LFSET[__reg2].b = 0;
        whs(__reg5, (random(18) + 1) * 100);
        ++__reg2;
    }

    if (!SPECT_U && STP_EX)
    {
        UITW_S = getTimer() + IUEWT_S * 1000;
        __reg5 = bst.attachMovie("quit_bt", "quit_bt", 3021);
        __reg5.onEnterFrame = function ()
        {
            this._parent._parent.iuewt(this);
        }
        ;
    }

    STP_EX = 1;
}

function atchs(t, a)
{
    var __reg1 = bst.attachMovie("cue", "cue", 899);
    __reg1.attachMovie("cuesrc_" + t, "ins", 10);
    __reg1.setMask(bst.cue_mask);
    __reg1.acdt = a;
    return __reg1;
}

function thrt()
{
    var __reg5 = 1;
    var __reg1 = 0;

    while (__reg1 < TFC.bnm)
    {
        var __reg2 = TFC.sqb[__reg1];
        if (!thpc(__reg2))
            __reg5 = 0;

        ++__reg1;
    }

    if (__reg5)
        sy_ydsp();

    if (HP_ACTIVE > 0)
    {
        var __reg3 = Math.round(bst._xmouse * 100);
        var __reg4 = Math.round(bst._ymouse * 100);
        var __reg8 = TFC.a_n + 200;
        var __reg6 = TFC.a_x - 200;
        if (__reg3 < __reg8)
            __reg3 = __reg8;
        else if (__reg3 > __reg6)
            __reg3 = __reg6;

        __reg8 = TFC.b_n + 200;
        __reg6 = TFC.b_x - 200;
        if (__reg4 < __reg8)
            __reg4 = __reg8;
        else if (__reg4 > __reg6)
            __reg4 = __reg6;

        if (HP_ACTIVE > 1)
        {
            if (__reg3 < 58500)
                __reg3 = 58500;
        }

        if (HP_ACTIVE == 3)
        {
            if (thmd(58500, TFC.b_ct, __reg3, __reg4) > 6200)
            {
                var __reg9 = thmg(58500, TFC.b_ct, __reg3, __reg4);
                var __reg7 = thmp(58500, TFC.b_ct, __reg9, 6200);
                __reg3 = __reg7[0];
                __reg4 = __reg7[1];
            }
        }

        bst.deny_logo._x = LFSET[STCH.t].h._x = LFSET[STCH.t].c._x = __reg3 / 100;
        bst.deny_logo._y = LFSET[STCH.t].h._y = LFSET[STCH.t].c._y = __reg4 / 100;
        if (sh_chhp(STCH.t, __reg3, __reg4))
        {
            bst.deny_logo._visible = 0;
            return;
        }

        bst.deny_logo._visible = 1;
    }
}

function iuewt(obj)
{
    if (getTimer() > UITW_S && UITW_S > 0)
    {
        UITW_S = 0;
        obj.removeMovieClip();
    }
}

function opwtc()
{
    obj = bst.cue;
    if (obj.ra > 0)
    {
        --obj.ra;
        obj.cr = obj.cr + obj.rs;
        obj._rotation = obj.cr;
        return;
    }

    if (obj.cr != obj.rt)
    {
        obj.cr = obj.rt;
        obj._rotation = obj.cr;
    }
}

function opcue(k)
{
    obj = bst.cue;
    obj.ins._x = obj.ins._x + 5;
    if (obj.ins._x >= TPSH.s / (TFC.vc / 100))
    {
        delete obj.onEnterFrame;
        obj.ins._x = -5;
        obj.play();
        var __reg1 = TPSH.t;
        delete (TPSH.t);
        for (var __reg2 in TPSH)
            LFSET[__reg1][__reg2] = TPSH[__reg2];

        sound_keykick(sound_vc, TPSH.s);
        TPSH = [];
        sh_hsrgs(__reg1, k);
    }
}

function rtcue()
{
    if (bst.tgpos == undefined)
    {
        obj = bst.cue;
        var __reg5 = thmg(obj._x, obj._y, bst._xmouse, bst._ymouse);
        var __reg10 = thmn(__reg5 + 180);
        obj._rotation = __reg10;
        if (STCH.press == 1)
        {
            var __reg7 = 100;
            obj.ins._x = obj.ins._x + STCH.cuer;
            if (obj.ins._x > __reg7)
            {
                obj.ins._x = __reg7;
                STCH.cuer = 0 - STCH.cuer;
            }
            else if (obj.ins._x < 0)
            {
                obj.ins._x = 0;
                STCH.cuer = 0 - STCH.cuer;
            }
        }

        bst.guide_sc.clear();
        if (GUIDE_ON && ztable.guide_switch.ST_ON)
        {
            // draw guide
            bst.guide_sc.lineStyle(1.5, 3394560, 100);

            var x = Math.round(bst._xmouse * 100);
            var y = Math.round(bst._ymouse * 100);

            var c = STCH.t;

            var ltBKD = [];
            ltBKD.u = -1;
            ltBKD.d = 9999999;
            ltBKD.px = 0;
            ltBKD.py = 0;

            if (EXTENDED_GUIDE_ON)
            {
                var a = LFSET[c].a;
                var b = LFSET[c].b;
                var d1 = thmd(a, b, x, y);
                var dx = (x - a) / d1;
                var dy = (y - b) / d1;

                for (var idx = 0; idx < TFC.bnm; idx++)
                {
                    if (idx == c || !LFSET[idx].e)
                        continue;

                    var a1 = LFSET[idx].a;
                    var b1 = LFSET[idx].b;

                    var d = dist_vec_to_line(a1, b1, a, b, x, y);
                    var d2 = thmd(a, b, a1, b1);

                    var d4 = Math.sqrt(d2 * d2 - d * d) - Math.sqrt(TFC.ow - d * d);

                    if (d >= TFC.od)
                        continue;

                    var d3 = thmd(x, y, a1, b1);

                    var d1_2 = d1 * d1;
                    var d2_2 = d2 * d2;
                    var d3_2 = d3 * d3;

                    if (d1_2 + d2_2 < d3_2 || d1_2 + d3_2 < d2_2)
                        continue;

                    if (d2 < ltBKD.d)
                    {
                        ltBKD.u = idx;
                        ltBKD.d = d2;
                        ltBKD.px = a + dx * d4;
                        ltBKD.py = b + dy * d4;
                    }
                }
            }

            if (ltBKD.u >= 0)
            {
                var d5 = thmd(ltBKD.px, ltBKD.py, LFSET[ltBKD.u].a, LFSET[ltBKD.u].b);
                var dx2 = (LFSET[ltBKD.u].a - ltBKD.px) / d5;
                var dy2 = (LFSET[ltBKD.u].b - ltBKD.py) / d5;

                bst.guide_sc.moveTo(obj._x, obj._y);
                bst.guide_sc.lineTo(ltBKD.px / 100, ltBKD.py / 100);

                bst.guide_sc.moveTo(LFSET[ltBKD.u].a / 100, LFSET[ltBKD.u].b / 100)
                bst.guide_sc.lineTo((LFSET[ltBKD.u].a + dx2 * 100000) / 100, (LFSET[ltBKD.u].b + dy2 * 100000) / 100);

                var p2x = ltBKD.px - dy2 * 100000;
                var p2y = ltBKD.py + dx2 * 100000;
                var p3x = ltBKD.px + dy2 * 100000;
                var p3y = ltBKD.py - dx2 * 100000;

                var dp2 = thmd(a, b, p2x, p2y);
                var dp3 = thmd(a, b, p3x, p3y);

                var px;
                var py;
                if (dp2 >= dp3)
                {
                    px = p2x;
                    py = p2y;
                }
                else
                {
                    px = p3x;
                    py = p3y;
                }

                bst.guide_sc.moveTo(ltBKD.px / 100, ltBKD.py / 100);
                bst.guide_sc.lineTo(px / 100, py / 100);
            }
            else
            {
                bst.guide_sc.moveTo(obj._x, obj._y);

                var an = TFC.a_n / 100;
                var ax = TFC.a_x / 100;
                var bn = TFC.b_n / 100;
                var bx = TFC.b_x / 100;

                r_w = ax - an;
                r_h = bx - bn;

                var ctop = thmj(obj._x, obj._y, bst._xmouse, bst._ymouse, an, bn, ax, bn); // testa colisão com o canto superior
                var cright = thmj(obj._x, obj._y, bst._xmouse, bst._ymouse, an, bx, ax, bx); // testa colisão com o canto direito
                var cleft = thmj(obj._x, obj._y, bst._xmouse, bst._ymouse, an, bn, an, bx); // testa colisão com o canto esquerdo
                var cbottom = thmj(obj._x, obj._y, bst._xmouse, bst._ymouse, ax, bn, ax, bx); // testa colisão com o canto inferior

                var __reg6;
                var __reg9;

                if (ctop[0] == 1 && obj._y > bn)
                {
                    __reg6 = [an + r_w * ctop[2], bn];
                    bst.guide_sc.lineTo(__reg6[0], __reg6[1]);
                    __reg9 = thmp(__reg6[0], __reg6[1], 0 - __reg5, 3000);
                    bst.guide_sc.lineTo(__reg9[0], __reg9[1]);
                }
                else if (cright[0] == 1 && obj._y < bx)
                {
                    __reg6 = [an + r_w * cright[2], bx];
                    bst.guide_sc.lineTo(__reg6[0], __reg6[1]);
                    __reg9 = thmp(__reg6[0], __reg6[1], 0 - __reg5, 3000);
                    bst.guide_sc.lineTo(__reg9[0], __reg9[1]);
                }
                else if (cleft[0] == 1 && obj._x > an)
                {
                    __reg6 = [an, bn + r_h * cleft[2]];
                    bst.guide_sc.lineTo(__reg6[0], __reg6[1]);
                    __reg9 = thmp(__reg6[0], __reg6[1], thmn(180 - __reg5), 3000);
                    bst.guide_sc.lineTo(__reg9[0], __reg9[1]);
                }
                else if (cbottom[0] == 1 && obj._x < ax)
                {
                    __reg6 = [ax, bn + r_h * cbottom[2]];
                    bst.guide_sc.lineTo(__reg6[0], __reg6[1]);
                    __reg9 = thmp(__reg6[0], __reg6[1], thmn(180 - __reg5), 3000);
                    bst.guide_sc.lineTo(__reg9[0], __reg9[1]);
                }
                else
                    bst.guide_sc.lineTo(bst._xmouse, bst._ymouse);
            }
        }

        ++obj.cntout;
        if (obj.cntout > 30)
        {
            obj.cntout = 0;
            STCH.t = Math.round(STCH.t);
            LFSET[STCH.t].a = Math.round(LFSET[STCH.t].a);
            LFSET[STCH.t].b = Math.round(LFSET[STCH.t].b);
            sy_ocsp(STCH.t, __reg10, [LFSET[STCH.t].a, LFSET[STCH.t].b]);
        }
    }
}

function shc_a()
{
    if (ztable.tbarea.hitTest(_root._xmouse, _root._ymouse))
    {
        if (_root.alertwindow != undefined)
        {
            if (_root.alertwindow.hitTest(_root._xmouse, _root._ymouse))
                return undefined;
        }

        if (bst.cue == undefined || bst.tgpos != undefined || thmd(LFSET[STCH.t].c._x, LFSET[STCH.t].c._y, bst._xmouse, bst._ymouse) < TFC["or"] / 100 + 5)
            return undefined;

        var __reg2 = 0;
        while (__reg2 < TFC.bnm)
        {
            if (LFSET[__reg2].e)
                delete (LFSET[__reg2].c.onRelease);

            ++__reg2;
        }

        STCH.press = 1;
    }
}
function shc_b()
{
    if (bst.cue != undefined)
    {
        if (STCH.press == 1)
        {
            obj = bst.cue;
            delete (obj.onEnterFrame);
            delete (obj.onMouseDown);
            delete (obj.onMouseUp);
            sh_sh();
            STCH = [];
            obj.ins._x = -5;
            obj.play();
        }
    }
}

function htgbs_a()
{
    var __reg1 = 0;
    for (;;)
    {
        if (__reg1 >= TFC.bnm)
            return;

        if (LFSET[__reg1].e && __reg1 != t)
        {
            var __reg2 = bst.attachMovie("htgy", "htb_" + __reg1, 10 + __reg1);
            __reg2._x = LFSET[__reg1].c._x;
            __reg2._y = LFSET[__reg1].c._y;
        }

        ++__reg1;
    }
}

function htgbs_b()
{
    var i = 0;
    for (;;)
    {
        if (i >= TFC.bnm)
            return;

        var h = eval("bst.htb_" + i);
        if (typeof h == "movieclip")
            h.removeMovieClip();

        ++i;
    }
}

function sh_chhp(t, a, b)
{
    var __reg1 = 0;
    while (__reg1 < TFC.bnm)
    {
        if (LFSET[__reg1].e && __reg1 != t)
        {
            if (thmd(a, b, LFSET[__reg1].a, LFSET[__reg1].b) - 200 < TFC.od)
                return 0;
        }

        ++__reg1;
    }

    return 1;
}

function sh_sbc(obj)
{
    if (ztable.tbarea.hitTest(_root._xmouse, _root._ymouse))
    {
        if (LFSET[obj.mi].e)
        {
            var __reg2 = 0;
            while (__reg2 < TFC.bnm)
            {
                if (LFSET[__reg2].e)
                    delete (LFSET[__reg2].c.onRelease);

                ++__reg2;
            }

            htgbs_b();
            STCH.t = obj.mi;
            sh_ist(STCH.hp);
        }
    }
}

function sh_stbhp()
{
    if (ztable.tbarea.hitTest(_root._xmouse, _root._ymouse))
    {
        var __reg3 = Math.round(LFSET[STCH.t].c._x * 100);
        var __reg2 = Math.round(LFSET[STCH.t].c._y * 100);
        var __reg5 = TFC.a_n + 200;
        var __reg4 = TFC.a_x - 200;
        if (__reg3 < __reg5)
            __reg3 = __reg5;
        else if (__reg3 > __reg4)
            __reg3 = __reg4;

        __reg5 = TFC.b_n + 200;
        __reg4 = TFC.b_x - 200;
        if (__reg2 < __reg5)
            __reg2 = __reg5;
        else if (__reg2 > __reg4)
            __reg2 = __reg4;

        if (sh_chhp(STCH.t, __reg3, __reg2))
        {
            bst.deny_logo._visible = 0;
            HP_ACTIVE = 0;
            ztable.tbarea.useHandCursor = false;
            delete (LFSET[STCH.t].c.onMouseUp);
            LFSET[STCH.t].c.swapDepths(STCH.t + 100);
            LFSET[STCH.t].a = __reg3;
            LFSET[STCH.t].b = __reg2;
            sh_ist(0);
        }
    }
}

function sh_ist(hp)
{
    LCOUTLS = 999;
    hp = hp * 1;
    if (hp > 0)
    {
        ztable.tbarea.useHandCursor = true;
        LFSET[STCH.t].c.swapDepths(699);
        LFSET[STCH.t].c.onMouseUp =
            function ()
            {
                sh_stbhp();
            };
        HP_ACTIVE = hp;
        return undefined;
    }

    HP_ACTIVE = 0;
    if (typeof LFSET[STCH.t] == "object")
    {
        if (!HDNL_DIS && !SPECT_U && SPIN_ON)
        {
            HDNL_DIS = 1;
            var __reg4 = bst.attachMovie("aim_tx", "aim_tx", 3260);
            __reg4._x = LFSET[STCH.t].c._x;
            __reg4._y = LFSET[STCH.t].c._y;
        }

        var __reg2 = atchs(CUE_CURR_PFX, "u");
        __reg2._x = LFSET[STCH.t].c._x;
        __reg2._y = LFSET[STCH.t].c._y;
        __reg2._rotation = thmn(thmg(__reg2._x, __reg2._y, bst._xmouse, bst._ymouse) + 180);
        __reg2.cntout = 999;
        __reg2.onEnterFrame =
            function ()
            {
                rtcue();
            };
        __reg2.onMouseDown =
            function ()
            {
                shc_a();
            };
        __reg2.onMouseUp =
            function ()
            {
                shc_b();
            };
        __reg2.filters = SHW_FT;
        if (SPIN_ON)
        {
            LFSET[STCH.t].c.onRelease =
                function ()
                {
                    opgh(this.mi);
                };
        }
    }
}

function opgh(c)
{
    if (!ztable.tbarea.hitTest(_root._xmouse, _root._ymouse) || !SPIN_ON)
        return undefined;

    if (typeof LFSET[c].c != "movieclip" || !LFSET[c].e || bst.tgpos != undefined)
        return undefined;

    bst.guide_sc.clear();
    var __reg2 = 70;
    var __reg5 = bst.attachMovie("tgpos", "tgpos", 4990);
    var __reg4 = LFSET[c].c._x;
    var __reg3 = LFSET[c].c._y;
    if (__reg4 < __reg2 + TFC.x_offs / 100)
        __reg4 = __reg2 + TFC.x_offs / 100;
    else if (__reg4 > (TFC.x_offs + TFC.fd_w) / 100 - __reg2)
        __reg4 = (TFC.x_offs + TFC.fd_w) / 100 - __reg2;

    if (__reg3 < __reg2 + TFC.y_offs / 100)
        __reg3 = __reg2 + TFC.y_offs / 100;
    else if (__reg3 > (TFC.y_offs + TFC.fd_h) / 100 - __reg2)
        __reg3 = (TFC.y_offs + TFC.fd_h) / 100 - __reg2;

    __reg5._x = __reg4;
    __reg5._y = __reg3;
    __reg5.filters = SHW_FT;
}

function sh_hsrgs(t, p)
{
    SH_RTGC = [];
    SH_RTGC.t = t;
    SH_RTGC.p = p;
}

function sh_stlp(a, b)
{
    STCH.tgp = [a, b];
}

function sh_stla(a)
{
    STCH.tga = a;
}

function sh_sh()
{
    PROC_RD = 1;
    ztable.tbarea.useHandCursor = false;
    bst.deny_logo._visible = 0;
    bst.htgy._visible = 0;
    bst.guide_sc.clear();
    var __reg1 = STCH.t;
    var __reg5 = bst.cue.ins._x * TFC.spf / 100;
    LFSET[__reg1].e = 0;
    LFSET[__reg1].v = thmn(bst.cue._rotation + 180);
    LFSET[__reg1].s = Math.round(TFC.vc * __reg5 + 1);
    sound_keykick(sound_vc, LFSET[__reg1].s);
    STCH.tga = Math.round(Math.abs(STCH.tga));
    LFSET[__reg1].r_mv = 0;
    LFSET[__reg1].r_ms = 0;
    if (STCH.tga > 0)
    {
        if (STCH.tgp[0] > 0)
        {
            LFSET[__reg1].r_mv = thmn(LFSET[__reg1].v - 90);
            LFSET[__reg1].r_ms = Math.round(Math.abs(STCH.tgp[0] * 3 * (STCH.tga * 2 / 100)));
        }
        else if (STCH.tgp[0] < 0)
        {
            LFSET[__reg1].r_mv = thmn(LFSET[__reg1].v + 90);
            LFSET[__reg1].r_ms = Math.round(Math.abs(STCH.tgp[0] * 3 * (STCH.tga * 2 / 100)));
        }
    }

    var __reg8 = thmn(thmg(0, 0, STCH.tgp[0], STCH.tgp[1]) + 90);
    var __reg7 = thmd(0, 0, STCH.tgp[0], STCH.tgp[1]);
    LFSET[__reg1].r_hv = thmn(LFSET[__reg1].v + __reg8);
    LFSET[__reg1].r_hs = Math.round(Math.abs(__reg7 * 3 * __reg5)) * 14;
    LFSET[__reg1].ri_h = Math.round(STCH.tgp[0] * -30 * __reg5);
    LFSET[__reg1].ri_v = Math.round(STCH.tgp[1] * -30 * __reg5);
    j.wheel._rotation = thmn(LFSET[__reg1].v - 180);
    LFSET[__reg1].e = 1;
    LFSET[__reg1].h._visible = 1;
    LFSET[__reg1].c._visible = 1;
    LFSET[__reg1].c._alpha = 100;
    var __reg3 = [];
    __reg3.push(Math.round(LFSET[__reg1].v * 100).toString(16));
    __reg3.push(Math.round(LFSET[__reg1].s).toString(16));
    __reg3.push(Math.round(LFSET[__reg1].r_mv * 100).toString(16));
    __reg3.push(Math.round(LFSET[__reg1].r_ms).toString(16));
    __reg3.push(Math.round(LFSET[__reg1].r_hv * 100).toString(16));
    __reg3.push(Math.round(LFSET[__reg1].r_hs).toString(16));
    __reg3.push(Math.round(LFSET[__reg1].ri_h).toString(16));
    __reg3.push(Math.round(LFSET[__reg1].ri_v).toString(16));
    var __reg6 = __reg3.join("{");
    var __reg2 = sy_pfgt(__reg6, 0);
    for (var __reg4 in __reg2)
        LFSET[__reg1][__reg4] = __reg2[__reg4];

    sy_osh(__reg6);
    sh_hsrgs(__reg1, 1);
}

function sy_htgy(c)
{
    bst.htgy._x = LFSET[c].a / 100;
    bst.htgy._y = LFSET[c].b / 100;
    bst.htgy._visible = 1;
}

function sy_gbs()
{
    var __reg3 = 0;
    var __reg4 = [];
    var __reg1 = 0;

    while (__reg1 < TFC.bnm)
    {
        if (LFSET[__reg1].e)
        {
            var __reg2 = [];
            __reg2.push(Math.round(__reg1 + TFC.sqc[__reg3]).toString(16));
            __reg2.push(Math.round(LFSET[__reg1].a + TFC.sqc[__reg3 + 1] * 1000).toString(16));
            __reg2.push(Math.round(LFSET[__reg1].b + TFC.sqc[__reg3 + 2] * 1000).toString(16));
            __reg4[__reg3] = __reg2.join("}");
            LFSET[__reg1].a = Math.round(parseInt(__reg2[1], 16) - TFC.sqc[__reg3 + 1] * 1000);
            LFSET[__reg1].b = Math.round(parseInt(__reg2[2], 16) - TFC.sqc[__reg3 + 2] * 1000);
            ++__reg3;
        }

        ++__reg1;
    }

    return __reg4.join("{");
}

function sy_sbs(t) // reposiciona as bolas em suas posições iniciais na mesa ou de acordo com uma posição desejada
{
    ztable.tbarea.useHandCursor = false;
    bst.guide_sc.clear();

    var __reg3 = [];
    var __reg6;

    if (t == "snooker")
    {
        __reg13 = [1, 2, 3, 4, 5];
        __reg20 = 24000;
        __reg16 = TFC.b_ct;
        __reg11 = TFC.od + 90;
        __reg15 = 1500;
        __reg21 = 61500;
        __reg22 = TFC.b_ct;
        __reg17 = __reg13.length;
        __reg4 = 7;
        __reg12 = __reg20;
        __reg23 = 0;
        __reg6 = 0;
        while (__reg6 < __reg17)
        {
            __reg9 = __reg13[__reg6];
            __reg8 = __reg16 - __reg9 * __reg11 / 2 + TFC["or"];
            __reg5 = 1;
            while (__reg5 <= __reg9)
            {
                LFSET[__reg4].a = __reg12 + (TFC.sqc[__reg4] - 7) * 10;
                LFSET[__reg4].b = __reg8 + (TFC.sqc[31 - __reg4] - 7) * 10;
                __reg8 = __reg8 + __reg11;
                thps(__reg4);
                ++__reg4;
                ++__reg5;
            }

            __reg12 = __reg12 - __reg15;
            ++__reg6;
        }

        LFSET[0].a = __reg21;
        LFSET[0].b = __reg22;
        thps(0);
        LFSET[1].a = TFC.x_offs + 55500;
        LFSET[1].b = TFC.b_ct - 6000;
        thps(1);
        LFSET[2].a = TFC.x_offs + 55500;
        LFSET[2].b = TFC.b_ct + 6000;
        thps(2);
        LFSET[3].a = TFC.x_offs + 55500;
        LFSET[3].b = __reg22;
        thps(3);
        LFSET[4].a = TFC.a_ct;
        LFSET[4].b = TFC.b_ct;
        thps(4);
        LFSET[5].a = LFSET[7].a + TFC.od + 200;
        LFSET[5].b = __reg22;
        thps(5);
        LFSET[6].a = TFC.x_offs + 8000;
        LFSET[6].b = __reg22;
        thps(6);

        return undefined;
    }
    else if (t == "carom")
    {
        LFSET[1].a = 21500;
        LFSET[1].b = TFC.b_ct - 5000;
        thps(1);
        LFSET[2].a = 21500;
        LFSET[2].b = TFC.b_ct;
        thps(2);
        LFSET[0].a = 58500;
        LFSET[0].b = TFC.b_ct;
        thps(0);
        return undefined;
    }
    else if (t == "pyramid" || t == "svoi")
    {
        __reg3 = [];
        __reg6 = 1;
        while (__reg6 < TFC.bnm)
        {
            if (TFC.sqc[__reg6] > 8)
                __reg3.push(__reg6);
            else
                __reg3.unshift(__reg6);

            ++__reg6;
        }

        __reg13 = [1, 2, 3, 4, 5];
        __reg20 = 24000;
        __reg16 = TFC.b_ct;
        __reg11 = TFC.od + 100;
        __reg15 = 1780;
        __reg21 = 58500;
        __reg22 = TFC.b_ct;
        __reg17 = __reg13.length;
        __reg4 = 0;
        __reg12 = __reg20;
        __reg23 = 0;
        __reg6 = 0;
        while (__reg6 < __reg17)
        {
            __reg9 = __reg13[__reg6];
            __reg8 = __reg16 - __reg9 * __reg11 / 2 + TFC["or"];
            __reg5 = 1;
            while (__reg5 <= __reg9)
            {
                LFSET[__reg3[__reg4]].a = __reg12 + (TFC.sqc[__reg4] - 7) * 10;
                LFSET[__reg3[__reg4]].b = __reg8 + (TFC.sqc[31 - __reg4] - 7) * 10;
                __reg8 = __reg8 + __reg11;
                thps(__reg3[__reg4]);
                ++__reg4;
                ++__reg5;
            }

            __reg12 = __reg12 - __reg15;
            ++__reg6;
        }
        LFSET[0].a = __reg21;
        LFSET[0].b = __reg22;
        thps(0);
        return undefined;
    }
    else if (t == "9ball")
    {
        var __reg19 = TFC.od + 130;
        var __reg18 = TFC["or"] + 70;
        var __reg7 = [];
        __reg7[0] = [];
        __reg7[9] = [22500, TFC.b_ct];
        __reg7[1] = [__reg7[9][0] + 3300, TFC.b_ct];
        __reg7[8] = [__reg7[9][0] - 3300, TFC.b_ct];
        __reg7[4] = [__reg7[9][0] - 1650, TFC.b_ct - __reg18];
        __reg7[6] = [__reg7[9][0] + 1650, TFC.b_ct - __reg18];
        __reg7[3] = [__reg7[9][0] - 1650, TFC.b_ct + __reg18];
        __reg7[5] = [__reg7[9][0] + 1650, TFC.b_ct + __reg18];
        __reg7[2] = [__reg7[9][0], TFC.b_ct - __reg19];
        __reg7[7] = [__reg7[9][0], TFC.b_ct + __reg19];
        __reg6 = 1;
        while (__reg6 < __reg7.length)
        {
            LFSET[__reg6].a = __reg7[__reg6][0] + (TFC.sqc[__reg6] - 7) * 10;
            LFSET[__reg6].b = __reg7[__reg6][1] + (TFC.sqc[31 - __reg6] - 7) * 10;
            thps(__reg6);
            ++__reg6;
        }

        __reg21 = 58500;
        __reg22 = TFC.b_ct;
        LFSET[0].a = __reg21;
        LFSET[0].b = __reg22;
        thps(0);

        return undefined;
    }
    else if (t == "gzpool")
    {
        __reg3 = [];
        __reg6 = 1;
        while (__reg6 < TFC.bnm)
        {
            if (TFC.sqc[__reg6] > 8)
                __reg3.push(__reg6);
            else
                __reg3.unshift(__reg6);

            ++__reg6;
        }

        __reg13 = [1, 2, 3, 4, 5];
        __reg20 = 24000;
        __reg16 = TFC.b_ct;
        __reg11 = TFC.od + 100;
        __reg15 = 1730;
        __reg21 = 58500;
        __reg22 = TFC.b_ct;
        __reg17 = __reg13.length;
        __reg4 = 0;
        __reg12 = __reg20;
        __reg23 = 0;
        __reg6 = 0;
        while (__reg6 < __reg17)
        {
            __reg9 = __reg13[__reg6];
            __reg8 = __reg16 - __reg9 * __reg11 / 2 + TFC["or"];
            __reg5 = 1;
            while (__reg5 <= __reg9)
            {
                LFSET[__reg3[__reg4]].a = __reg12 + (TFC.sqc[__reg4] - 7) * 10;
                LFSET[__reg3[__reg4]].b = __reg8 + (TFC.sqc[31 - __reg4] - 7) * 10;
                __reg8 = __reg8 + __reg11;
                thps(__reg3[__reg4]);
                ++__reg4;
                ++__reg5;
            }

            __reg12 = __reg12 - __reg15;
            ++__reg6;
        }

        LFSET[0].a = __reg21;
        LFSET[0].b = __reg22;
        thps(0);

        return undefined;
    }
    else if (t == "straight" || t == "8ball" || t == "brpool")
    {
        __reg3 = [];
        __reg6 = 1;
        while (__reg6 < TFC.bnm)
        {
            if (TFC.sqc[__reg6] > 8)
                __reg3.push(__reg6);
            else
                __reg3.unshift(__reg6);

            ++__reg6;
        }

        __reg6 = 1;
        while (__reg6 < TFC.bnm)
        {
            if (__reg3[__reg6] == 8)
            {
                __reg3[__reg6] = __reg3[4];
                __reg3[4] = 8;
                break;
            }

            ++__reg6;
        }

        var __reg13 = [1, 2, 3, 4, 5];
        var __reg20 = 24000;
        var __reg16 = TFC.b_ct;
        var __reg11 = TFC.od + 100;
        var __reg15 = 1620;
        var __reg21 = 58500;
        var __reg22 = TFC.b_ct;
        var __reg17 = __reg13.length;
        var __reg4 = 0;
        var __reg12 = __reg20;
        var __reg23 = 0;
        __reg6 = 0;
        while (__reg6 < __reg17)
        {
            var __reg9 = __reg13[__reg6];
            var __reg8 = __reg16 - __reg9 * __reg11 / 2 + TFC["or"];
            var __reg5 = 1;
            while (__reg5 <= __reg9)
            {
                LFSET[__reg3[__reg4]].a = __reg12 + (TFC.sqc[__reg4] - 7) * 10;
                LFSET[__reg3[__reg4]].b = __reg8 + (TFC.sqc[31 - __reg4] - 7) * 10;
                __reg8 = __reg8 + __reg11;
                thps(__reg3[__reg4]);
                ++__reg4;
                ++__reg5;
            }

            __reg12 = __reg12 - __reg15;
            ++__reg6;
        }

        LFSET[0].a = __reg21;
        LFSET[0].b = __reg22;
        thps(0);

        return undefined;
    }

    t = t.split("{", TFC.bnm);
    __reg6 = 0;
    for (;;)
    {
        if (__reg6 >= TFC.bnm)
            return;

        var __reg10 = _root.lim_split(t[__reg6], "}", 4);
        var __reg2 = Math.round(parseInt(__reg10[0], 16) - TFC.sqc[__reg6]);
        var v = Math.round(parseInt(__reg10[3], 16));
        if (typeof LFSET[__reg2] == "object")
        {
            LFSET[__reg2].s = 0;
            LFSET[__reg2].v = 0;
            LFSET[__reg2].r_mv = 0;
            LFSET[__reg2].r_ms = 0;
            LFSET[__reg2].r_hv = 0;
            LFSET[__reg2].r_hs = 0;
            LFSET[__reg2].ri_h = 0;
            LFSET[__reg2].ri_v = 0;
            LFSET[__reg2].a = Math.round(parseInt(__reg10[1], 16) - TFC.sqc[__reg6 + 1] * 1000);
            LFSET[__reg2].b = Math.round(parseInt(__reg10[2], 16) - TFC.sqc[__reg6 + 2] * 1000);
            if (v)
            {
                LFSET[__reg2].e = 1;
                LFSET[__reg2].h._visible = 1;
                LFSET[__reg2].c._visible = 1;
                LFSET[__reg2].c._alpha = 100;
            }
            else
            {
                LFSET[__reg2].e = 0;
                LFSET[__reg2].h._visible = 0;
                LFSET[__reg2].c._visible = 0;
                LFSET[__reg2].c._alpha = 0;
            }

            thps(__reg2);
        }

        ++__reg6;
    }
}

function sy_cpa(tgb, hp)
{
    PROC_RD = 1;
    OPCTVD = [];
    STD_CONFIRM_CUP = 0;
    STBL_SET = 0;
    HP_ACTIVE = 0;
    ztable.tbarea.useHandCursor = false;
    bst.deny_logo._visible = 0;
    STCH = [];
    STCH.press = 0;
    STCH.cuer = 4;
    STCH.tgp = [0, 0];
    STCH.tga = 0;
    STCH.hp = hp;
    if (tgb == "0")
    {
        STCH.t = 0;
        sh_ist(hp);
        return;
    }

    htgbs_a();
    var __reg2 = 0;
    for (;;)
    {
        if (__reg2 >= TFC.bnm)
            return;

        if (LFSET[__reg2].e)
        {
            LFSET[__reg2].c.onRelease =
                function ()
                {
                    this._parent._parent.sh_sbc(this);
                };
        }

        ++__reg2;
    }
}

function sy_pfgt(r, fp)
{
    var __reg2 = [];
    var __reg3;

    if (fp)
    {
        __reg3 = _root.lim_split(r, "{", 9);
        __reg2.t = Math.round(parseInt(__reg3[0], 16));
    }
    else
    {
        __reg3 = _root.lim_split(r, "{", 8);
        __reg3.unshift(0);
    }

    __reg2.v = thmn(parseInt(__reg3[1], 16) / 100);
    if (isNaN(__reg2.v))
        __reg2.v = 0;

    __reg2.s = Math.round(parseInt(__reg3[2], 16));
    if (isNaN(__reg2.s))
        __reg2.s = 0;

    __reg2.r_mv = thmn(parseInt(__reg3[3], 16) / 100);
    if (isNaN(__reg2.r_mv))
        __reg2.r_mv = 0;

    __reg2.r_ms = Math.round(parseInt(__reg3[4], 16));
    if (isNaN(__reg2.r_ms))
        __reg2.r_ms = 0;

    if (__reg2.r_ms > 1500)
        __reg2.r_ms = 1500;

    __reg2.r_hv = thmn(parseInt(__reg3[5], 16) / 100);
    if (isNaN(__reg2.r_hv))
        __reg2.r_hv = 0;

    __reg2.r_hs = Math.round(parseInt(__reg3[6], 16));
    if (isNaN(__reg2.r_hs))
        __reg2.r_hs = 0;

    if (__reg2.r_hs > 1500)
        __reg2.r_hs = 1500;

    __reg2.ri_h = Math.round(parseInt(__reg3[7], 16));
    if (isNaN(__reg2.ri_h))
        __reg2.ri_h = 0;

    __reg2.ri_v = Math.round(parseInt(__reg3[8], 16));
    if (isNaN(__reg2.ri_v))
        __reg2.ri_v = 0;

    return __reg2;
}

function sy_psh(r)
{
    PROC_RD = 1;
    OPCTVD = [];
    STD_CONFIRM_CUP = 0;
    STBL_SET = 0;
    bst.deny_logo._visible = 0;
    bst.htgy._visible = 0;
    bst.guide_sc.clear();
    TPSH = sy_pfgt(r, 1);
    var __reg2 = TPSH.t;
    if (LFSET[__reg2].e)
    {
        var __reg1 = atchs(CUE_OPP_PFX, "p");
        __reg1._x = LFSET[__reg2].c._x;
        __reg1._y = LFSET[__reg2].c._y;
        __reg1._rotation = thmn(TPSH.v + 180);
        __reg1.onEnterFrame =
            function ()
            {
                opcue(2);
            };
        __reg1.filters = SHW_FT;
    }
}

function sy_bshe(t, st)
{
    PROC_RD = 1;
    bst.deny_logo._visible = 0;
    bst.htgy._visible = 0;
    bst.guide_sc.clear();
    if (LFSET[t].e)
    {
        if (typeof st != "object")
            st = [];

        var __reg9;
        var __reg17;
        var __reg23 = [];
        var __reg25 = [];
        var __reg1 = 0;
        var __reg27;
        var __reg28 = [];
        var __reg30;
        var __reg33;
        var __reg34;

        while (__reg1 < st.length)
        {
            __reg25[st[__reg1]] = 1;
            ++__reg1;
        }

        if (!TFC.upk)
        {
            __reg17 = random(40000) + 1000;
            __reg9 = random(360) - 180;
            __reg1 = TFC.bnm;
            while (__reg1 >= 0)
            {
                if (LFSET[__reg1].e && t != __reg1 && __reg25[__reg1])
                {
                    __reg17 = thmd(LFSET[t].a, LFSET[t].b, LFSET[__reg1].a, LFSET[__reg1].b);
                    __reg9 = thmg(LFSET[t].a, LFSET[t].b, LFSET[__reg1].a, LFSET[__reg1].b);
                    break;
                }

                --__reg1;
            }

            if (__reg17 > 15000)
                __reg34 = (16 + random(6)) * 100;
            else
                __reg34 = (10 + random(11)) * 100;

            TPSH = [];
            TPSH.t = Math.round(t);
            TPSH.v = thmn(__reg9);
            TPSH.s = __reg34;
            TPSH.r_mv = 0;
            TPSH.r_ms = 0;
            TPSH.r_hv = 0;
            TPSH.r_hs = 0;
            TPSH.ri_h = 0;
            TPSH.ri_v = 0;

            __reg30 = atchs(CUE_OPP_PFX, "b");
            __reg30._x = LFSET[t].c._x;
            __reg30._y = LFSET[t].c._y;
            __reg30._rotation = thmn(TPSH.v + 180);
            __reg30.onEnterFrame =
                function ()
                {
                    opcue(3);
                };

            __reg30.filters = SHW_FT;
            __reg28 = [];
            __reg28.push(Math.round(TPSH.v * 100).toString(16));
            __reg28.push(Math.round(TPSH.s).toString(16));
            __reg28.push(Math.round(TPSH.r_mv * 100).toString(16));
            __reg28.push(Math.round(TPSH.r_ms).toString(16));
            __reg28.push(Math.round(TPSH.r_hv * 100).toString(16));
            __reg28.push(Math.round(TPSH.r_hs).toString(16));
            __reg28.push(Math.round(TPSH.ri_h).toString(16));
            __reg28.push(Math.round(TPSH.ri_v).toString(16));
            __reg33 = __reg28.join("{");
            __reg27 = sy_pfgt(__reg33, 0);
            for (var __reg32 in __reg27)
                TPSH[__reg32] = __reg27[__reg32];

            sy_osh(__reg33);
            return undefined;
        }

        var __reg16 = TFC.od - 10;
        var __reg35 = [];
        __reg1 = 0;
        while (__reg1 < TFC.bnm)
        {
            if (LFSET[__reg1].e && t != __reg1 && __reg25[__reg1])
            {
                __reg17 = thmd(LFSET[t].a, LFSET[t].b, LFSET[__reg1].a, LFSET[__reg1].b);
                __reg9 = thmg(LFSET[t].a, LFSET[t].b, LFSET[__reg1].a, LFSET[__reg1].b);
                var __reg5 = 0;
                while (__reg5 < 6)
                {
                    var __reg4 = [];
                    var __reg19 = thmd(LFSET[__reg1].a, LFSET[__reg1].b, TFC["k_" + __reg5 + "bottg"][0], TFC["k_" + __reg5 + "bottg"][1]);
                    var __reg11 = thmg(LFSET[__reg1].a, LFSET[__reg1].b, TFC["k_" + __reg5 + "bottg"][0], TFC["k_" + __reg5 + "bottg"][1]);
                    var __reg15 = thmn(__reg11 - __reg9);
                    __reg4.cue_crs = 0;
                    __reg4.tg_crs = 0;
                    __reg4.fr_ang = __reg15;
                    __reg4.sumd = __reg17 + __reg19;
                    var __reg8 = Math.sin(TFC.te * __reg15) * __reg16;
                    var __reg20 = __reg8 * __reg8;
                    var __reg22 = Math.sqrt(Math.abs(__reg16 * __reg16 - __reg20));
                    var __reg21 = __reg17 - Math.abs(__reg22);
                    var __reg18 = Math.atan(__reg8 / __reg21) / TFC.te;
                    __reg4.v = __reg9 - __reg18;
                    var __reg2 = 0;
                    var __reg6;
                    var __reg14;
                    var __reg12;
                    var __reg13;
                    while (__reg2 < TFC.bnm)
                    {
                        if (LFSET[__reg2].e && t != __reg1 && __reg1 != __reg2)
                        {
                            __reg13 = thmd(LFSET[t].a, LFSET[t].b, LFSET[__reg2].a, LFSET[__reg2].b);
                            __reg12 = thmg(LFSET[t].a, LFSET[t].b, LFSET[__reg2].a, LFSET[__reg2].b);
                            __reg6 = Math.abs(thmn(__reg9 - __reg12));
                            if (__reg6 < 90)
                            {
                                __reg14 = Math.abs(Math.sin(TFC.te * __reg6) * __reg13);
                                if (__reg14 <= TFC.od)
                                    ++__reg4.cue_crs;
                            }
                        }

                        ++__reg2;
                    }

                    __reg2 = 0;
                    while (__reg2 < TFC.bnm)
                    {
                        if (LFSET[__reg2].e && t != __reg1 && __reg1 != __reg2)
                        {
                            __reg13 = thmd(LFSET[__reg1].a, LFSET[__reg1].b, LFSET[__reg2].a, LFSET[__reg2].b);
                            __reg12 = thmg(LFSET[__reg1].a, LFSET[__reg1].b, LFSET[__reg2].a, LFSET[__reg2].b);
                            __reg6 = Math.abs(thmn(__reg11 - __reg12));
                            if (Math.abs(__reg6) < 90)
                            {
                                __reg14 = Math.abs(Math.sin(TFC.te * __reg6) * __reg13);
                                if (__reg14 <= TFC.od)
                                    ++__reg4.tg_crs;
                            }
                        }

                        ++__reg2;
                    }

                    __reg23["_" + __reg1 + "_" + __reg5] = __reg4;
                    ++__reg5;
                }
            }

            ++__reg1;
        }

        var __reg24 = "";
        var __reg29;
        for (var __reg31 in __reg23)
        {
            var __reg7 = __reg23[__reg31];
            if (__reg24 == "")
                __reg24 = __reg31;
            else
            {
                var __reg10 = 0;
                __reg29 = __reg23[__reg24];
                if (Math.abs(__reg7.fr_ang) < 80)
                {
                    if (__reg7.cue_crs == 0 && __reg7.tg_crs == 0 && (__reg29.cue_crs > 0 || __reg29.tg_crs > 0))
                        __reg10 = 1;

                    if ((__reg7.cue_crs == 0 || __reg7.tg_crs == 0) && __reg29.cue_crs > 0 && __reg29.tg_crs > 0)
                        __reg10 = 1;

                    if (__reg29.cue_crs == 0 && __reg29.tg_crs == 0 && (__reg7.cue_crs > 0 || __reg7.tg_crs > 0))
                        __reg10 = -1;

                    if ((__reg29.cue_crs == 0 || __reg29.tg_crs == 0) && __reg7.cue_crs > 0 && __reg7.tg_crs > 0)
                        __reg10 = -1;

                    if (__reg10 == 0)
                    {
                        if (Math.abs(__reg7.fr_ang) < Math.abs(__reg29.fr_ang))
                            __reg10 = 1;
                    }

                    if (__reg10 == 1)
                        __reg24 = __reg31;
                }
            }
        }

        __reg29 = __reg23[__reg24];
        if (__reg29 == undefined)
        {
            __reg29 = [];
            __reg29.v = random(360) - 180;
            __reg34 = (3 + random(8)) * 100;
        }
        else if (Math.abs(__reg29.fr_ang) > 20 || __reg29.sumd > 15000)
            __reg34 = (16 + random(6)) * 100;
        else
            __reg34 = (10 + random(11)) * 100;

        RESVC = thma_d(__reg29.v);
        TPSH = [];
        TPSH.t = Math.round(t);
        TPSH.v = thmn(__reg29.v);
        TPSH.s = __reg34;
        TPSH.r_mv = 0;
        TPSH.r_ms = 0;
        TPSH.r_hv = 0;
        TPSH.r_hs = 0;
        TPSH.ri_h = 0;
        TPSH.ri_v = 0;
        __reg30 = atchs(CUE_OPP_PFX, "b");
        __reg30._x = LFSET[t].c._x;
        __reg30._y = LFSET[t].c._y;
        __reg30._rotation = thmn(TPSH.v + 180);
        __reg30.onEnterFrame =
            function ()
            {
                opcue(3);
            };
        __reg30.filters = SHW_FT;
        __reg28 = [];
        __reg28.push(Math.round(TPSH.v * 100).toString(16));
        __reg28.push(Math.round(TPSH.s).toString(16));
        __reg28.push(Math.round(TPSH.r_mv * 100).toString(16));
        __reg28.push(Math.round(TPSH.r_ms).toString(16));
        __reg28.push(Math.round(TPSH.r_hv * 100).toString(16));
        __reg28.push(Math.round(TPSH.r_hs).toString(16));
        __reg28.push(Math.round(TPSH.ri_h).toString(16));
        __reg28.push(Math.round(TPSH.ri_v).toString(16));
        __reg33 = __reg28.join("{");
        __reg27 = sy_pfgt(__reg33, 0);
        for (__reg32 in __reg27)
            TPSH[__reg32] = __reg27[__reg32];

        sy_osh(__reg33);
    }
}

function sy_acud(vf)
{
    if (typeof vf == "object")
    {
        if (vf.i != undefined)
        {
            if (LFSET[vf.i].e)
                OPCTVD.i = vf.i;
        }

        if (typeof vf.p == "object" && OPCTVD.i != undefined)
        {
            var __reg5 = Math.round(parseInt(vf.p[0], 16));
            var __reg4 = Math.round(parseInt(vf.p[1], 16));
            if (isNaN(__reg5))
                __reg5 = 0;

            if (isNaN(__reg4))
                __reg4 = 0;

            if (__reg5 < TFC.a_n)
                __reg5 = TFC.a_n;
            else if (__reg5 > TFC.a_x)
                __reg5 = TFC.a_x;

            if (__reg4 < TFC.b_n)
                __reg4 = TFC.b_n;
            else if (__reg4 > TFC.b_x)
                __reg4 = TFC.b_x;

            LFSET[vf.i].a = __reg5;
            LFSET[vf.i].b = __reg4;
            thps(vf.i);
        }

        var __reg1 = vf.a;
        if (isNaN(__reg1) || !LFSET[OPCTVD.i].e || OPCTVD.i == undefined)
            return undefined;

        if (Math.abs(__reg1) > 360)
            __reg1 = 0;

        __reg1 = Math.round(thmn(__reg1) * 10) / 10;
        if (Math.abs(__reg1) == 180 || __reg1 == 0)
            __reg1 = Math.round(thmn(__reg1 + 0.1) * 10) / 10;

        var __reg2 = bst.cue;
        if (__reg2.acdt == undefined)
        {
            __reg2 = atchs(CUE_OPP_PFX, "w");
            __reg2._x = LFSET[OPCTVD.i].c._x;
            __reg2._y = LFSET[OPCTVD.i].c._y;
            __reg2.onEnterFrame =
                function ()
                {
                    opwtc();
                };
            __reg2.filters = SHW_FT;
            __reg2._rotation = __reg1;
            __reg2.cr = __reg1;
        }
        else if (__reg2.acdt != "w")
            return undefined;

        __reg2.rt = __reg1;
        __reg2.ra = 3;
        __reg2.rs = thmn(__reg1 - __reg2.cr) / 3;
    }
}

function sy_ocsp(t, g, p)
{
    g = Math.round(g);
    var __reg3;
    if (STBL_SET)
    {
        if (STD_CONFIRM_CUP || g == LCOUTLS)
            return undefined;

        LCOUTLS = g;
        __reg3 = {f: "cu", a: g};
    }
    else
    {
        STBL_SET = 1;
        __reg3 = {f: "cuf", a: g, v: t + "_" + p[0].toString(16) + "_" + p[1].toString(16)};
    }

    STD_CONFIRM_CUP = 1;
    _parent._parent.send_gamecom(__reg3);
}

function sy_cfcsp()
{
    STD_CONFIRM_CUP = 0;
}

function sy_osh(r)
{
    _parent.stop_timer();
    _parent._parent.send_gamecom({f: "ht", v: r});
}

function sy_ydsp()
{
    if (typeof SH_RTGC == "object")
    {
        if (SPECT_U)
        {
            SH_RTGC = "";
            PROC_RD = 0;
            _parent._parent.send_gamecom({f: "cj"});
            _parent.spbhg();
            return undefined;
        }
    }
    else
        return undefined;

    var __reg7 = "";
    var __reg5;
    if (typeof SH_RTGC.pk == "object")
    {
        __reg5 = SH_RTGC.pk.length;
        var __reg2 = 0;
        while (__reg2 < __reg5)
        {
            SH_RTGC.pk[__reg2] = Math.round(SH_RTGC.pk[__reg2][0] + TFC.sqc[__reg2 + 2]).toString(16) + "}" + SH_RTGC.pk[__reg2][1];
            ++__reg2;
        }

        __reg7 = SH_RTGC.pk.join("{");
    }

    var __reg4 = "";
    if (typeof SH_RTGC.ct == "object")
    {
        __reg4 = [];
        var __reg3 = [];
        __reg5 = SH_RTGC.ct.length;
        __reg2 = 0;
        while (__reg2 < __reg5)
        {
            if (__reg3["_" + SH_RTGC.ct[__reg2]] != 1)
            {
                __reg3["_" + SH_RTGC.ct[__reg2]] = 1;
                __reg4.push(Math.round(SH_RTGC.ct[__reg2]).toString(16));
            }

            ++__reg2;
        }
        __reg4 = __reg4.join("{");
    }

    _parent.pychs();
    var __reg6 = Math.round(SH_RTGC.t).toString(16) + ";" + sy_gbs() + ";" + __reg7 + ";" + __reg4;
    if (SH_RTGC.p == 1 || SH_RTGC.p == 3)
        _parent._parent.send_gamecom({f: "prm", v: __reg6});
    else
        _parent._parent.send_gamecom({f: "cj"});

    SH_RTGC = "";
}

function sy_fdsi(w, m, r)
{
    ztable.tbarea.useHandCursor = false;
    bst.deny_logo._visible = 0;
    bst.htgy._visible = 0;
    bst.guide_sc.clear();
    if (r == "1" && !SPECT_U)
        bst.attachMovie("replay_bt", "replay_bt", 3020);

    bst.attachMovie("quit_bt", "quit_bt", 3021);
    var obj;
    if (w == 1 || w == 2)
    {
        obj = bst.attachMovie("end_winner", "win_res", 3010);
        if (!SPECT_U)
            obj.W_SOUND = m;

        var n = eval("_parent.scboard.playername" + w);
        if (n == undefined)
            n = "";

        obj.winner_name = n;
    }
    else
        obj = bst.attachMovie("end_over", "win_res", 3010);

    obj.filters = SHW_FT;
}

function sy_esch(i)
{
    var __reg1 = bst.attachMovie("sn_error", "sn_error", 3030);
    __reg1.filters = SHW_FT;
    __reg1.i = i;
}

function zoom_switch()
{
    if (bst._xscale > 101)
    {
        bst._x = bst._y = 0;
        ztable._x = ztable._y = 0;
        bst._xscale = bst._yscale = 100;
        ztable._xscale = ztable._yscale = 100;
        return;
    }

    bst._y = ztable._y = -85;
    bst._xscale = bst._yscale = ztable._xscale = ztable._yscale = 124.9;
}

CUE_CURR_PFX = "";
CUE_OPP_PFX = "";
GUIDE_ON = false;
EXTENDED_GUIDE_ON = false;
SPIN_ON = 0;
SPECT_U = 0;
IUEWT_S = 5;
HDNL_DIS = 0;
soundRat_kick = 3;
soundRat_bordkick = 2;
soundRat_keykick = 3;
soundRat_pocket = 4;
SH_RTGC = "";
OPCTVD = [];
LCOUTLS = 999;
STD_CONFIRM_CUP = 0;
STBL_SET = 0;
HP_ACTIVE = 0;
SHW_FT = [new flash.filters.DropShadowFilter(9, 45, 0, 0.4, 6, 6, 1, 3, false, false, false)];
STCH = [];
TPSH = [];
PROC_RD = 0;
STP_EX = 0;
UITW_S = 0;

this.createEmptyMovieClip("sound_vc", 3990);

if (_root.zoom_keyListener == undefined)
{
    _root.zoom_keyListener = new Object();
    _root.zoom_keyListener.onKeyDown =
        function ()
        {
            if (Key.getCode() == 90 && _root._xmouse < 800)
            {
                _root.currentmod.sections.sc_game.sectionmod.game_mod.gkernel.zoom_switch();
            }
        };
    Key.addListener(_root.zoom_keyListener);
}