# TRITIUM-PROVENANCE sha256=7ab3f2fa4f8df8640be261938568a4bd5a768201d8fa662258c66b76d58f2c1d lang=python
# TRITIUM-HEIGHT high=0.20 mid=0.51 low=0.29 fns=16
# TRITIUM-PSEUDO fn=fsin
#| fn fsin(x):
#|   return a * (1.0 + x2 * (-0.16666666666666666 + x2 * (0.008333333333333333 + x2 * (-0.0001984126984126984 + x2 * 2.7557319223985893e-06))))
# TRITIUM-HEIGHT fn=fsin high=0.00 mid=0.44 low=0.56 role=algo_mid
def fsin(x: float) -> float:
    pi = 3.141592653589793
    two = 6.283185307179586
    a = x
    while a > pi:
        a = a - two
    while a <= -pi:
        a = a + two
    x2 = a * a
    return a * (1.0 + x2 * (-0.16666666666666666 + x2 * (0.008333333333333333 + x2 * (-0.0001984126984126984 + x2 * 2.7557319223985893e-06))))

# TRITIUM-PSEUDO fn=fcos
#| fn fcos(x):
#|   return 1.0 + x2 * (-0.5 + x2 * (0.041666666666666664 + x2 * (-0.001388888888888889 + x2 * 2.48015873015873e-05)))
# TRITIUM-HEIGHT fn=fcos high=0.00 mid=0.44 low=0.56 role=algo_mid
def fcos(x: float) -> float:
    pi = 3.141592653589793
    two = 6.283185307179586
    a = x
    while a > pi:
        a = a - two
    while a <= -pi:
        a = a + two
    x2 = a * a
    return 1.0 + x2 * (-0.5 + x2 * (0.041666666666666664 + x2 * (-0.001388888888888889 + x2 * 2.48015873015873e-05)))

# TRITIUM-PSEUDO fn=fsqrt
#| fn fsqrt(x):
#|   return g
# TRITIUM-HEIGHT fn=fsqrt high=0.00 mid=0.63 low=0.37 role=algo_mid
def fsqrt(x: float) -> float:
    if x <= 0.0:
        return 0.0
    g = x
    i = 0
    while i < 8:
        g = 0.5 * (g + x / g)
        i = i + 1
    return g

# TRITIUM-PSEUDO fn=haversine_f
#| fn haversine_f(lat1, lon1, lat2, lon2):
#|   fsin(...)
#|   fsqrt(...)
#|   fcos(...)
#|   return 2.0 * fsqrt(h)
# TRITIUM-HEIGHT fn=haversine_f high=0.75 mid=0.25 low=0.00
def haversine_f(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    dlat = lat2 - lat1
    dlon = lon2 - lon1
    aa = fsin(dlat / 2.0)
    bb = fsin(dlon / 2.0)
    h = aa * aa + fcos(lat1) * fcos(lat2) * bb * bb
    return 2.0 * fsqrt(h)

# TRITIUM-PSEUDO fn=haversine_km_f
#| fn haversine_km_f(lat1, lon1, lat2, lon2):
#|   return 6371.0 * haversine_f(lat1, lon1, lat2, lon2)
# TRITIUM-HEIGHT fn=haversine_km_f high=1.00 mid=0.00 low=0.00
def haversine_km_f(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    return 6371.0 * haversine_f(lat1, lon1, lat2, lon2)

# TRITIUM-PSEUDO fn=_atan_unit
#| fn _atan_unit(a):
#|   return r
# TRITIUM-HEIGHT fn=_atan_unit high=0.00 mid=1.00 low=0.00 role=algo_mid
def _atan_unit(a: float) -> float:
    t8 = 0.41421356237309503
    folded = 0
    t = a
    if t > t8:
        t = (1.0 - t) / (1.0 + t)
        folded = 1
    z2 = t * t
    r = t * (1.0 + z2 * (-0.3333333333333333 + z2 * (0.2 + z2 * (-0.14285714285714285 + z2 * (0.1111111111111111 + z2 * -0.09090909090909091)))))
    if folded == 1:
        r = 0.7853981633974483 - r
    return r

# TRITIUM-PSEUDO fn=fatan_poly
#| fn fatan_poly(z):
#|   _atan_unit(...)
#|   return r
# TRITIUM-HEIGHT fn=fatan_poly high=0.13 mid=0.87 low=0.00
def fatan_poly(z: float) -> float:
    neg = 0
    a = z
    if a < 0.0:
        a = 0.0 - a
        neg = 1
    swapped = 0
    if a > 1.0:
        a = 1.0 / a
        swapped = 1
    r = _atan_unit(a)
    if swapped == 1:
        r = 1.5707963267948966 - r
    if neg == 1:
        r = 0.0 - r
    return r

# TRITIUM-PSEUDO fn=fatan2
#| fn fatan2(y, x):
#|   fatan_poly(...)
# TRITIUM-HEIGHT fn=fatan2 high=0.19 mid=0.81 low=0.00 role=algo_mid
def fatan2(y: float, x: float) -> float:
    ay = y
    if ay < 0.0:
        ay = 0.0 - ay
    ax = x
    if ax < 0.0:
        ax = 0.0 - ax
    if ax >= ay:
        if ax == 0.0:
            return 0.0
        a = fatan_poly(ay / ax)
    else:
        if ay == 0.0:
            return 0.0
        a = 1.5707963267948966 - fatan_poly(ax / ay)
    if x < 0.0:
        if y < 0.0:
            return a - 3.141592653589793
        return 3.141592653589793 - a
    else:
        if y < 0.0:
            return 0.0 - a
        return a

# TRITIUM-PSEUDO fn=bearing_f
#| fn bearing_f(lat1, lon1, lat2, lon2):
#|   fsin(...)
#|   fcos(...)
#|   fatan2(...)
#|   return br
# TRITIUM-HEIGHT fn=bearing_f high=0.69 mid=0.31 low=0.00
def bearing_f(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    dlon = lon2 - lon1
    sd = fsin(dlon)
    cl2 = fcos(lat2)
    y = sd * cl2
    cl1 = fcos(lat1)
    sl2 = fsin(lat2)
    sl1 = fsin(lat1)
    cl2b = fcos(lat2)
    cd = fcos(dlon)
    x = cl1 * sl2 - sl1 * cl2b * cd
    br = fatan2(y, x)
    return br

# TRITIUM-PSEUDO fn=bearing_deg_f
#| fn bearing_deg_f(lat1, lon1, lat2, lon2):
#|   bearing_f(...)
#|   return d
# TRITIUM-HEIGHT fn=bearing_deg_f high=0.21 mid=0.28 low=0.52
def bearing_deg_f(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    br = bearing_f(lat1, lon1, lat2, lon2)
    d = br * 57.29577951308232
    while d < 0.0:
        d = d + 360.0
    while d >= 360.0:
        d = d - 360.0
    return d

# TRITIUM-PSEUDO fn=interest_radius_f
#| fn interest_radius_f(dx, dy, r):
#|   return int(dx * dx + dy * dy <= r * r)
# TRITIUM-HEIGHT fn=interest_radius_f high=0.00 mid=1.00 low=0.00 role=leaf_charset
def interest_radius_f(dx: float, dy: float, r: float) -> int:
    return int(dx * dx + dy * dy <= r * r)

# TRITIUM-PSEUDO fn=mmog_interest_filter
#| fn mmog_interest_filter(vals, ys, n, cx, cy, r, out):
#|   interest_radius_f(...)
#|   float(...)
#|   return m
# TRITIUM-HEIGHT fn=mmog_interest_filter high=0.20 mid=0.26 low=0.54 role=algo_mid
def mmog_interest_filter(vals: list[float], ys: list[float], n: int, cx: float, cy: float, r: float, out: list[int]) -> int:
    m = 0
    i = 0
    while i < n:
        if interest_radius_f(vals[i] - cx, ys[i] - cy, r) == float(1):
            out[m] = i
            m = m + 1
        i = i + 1
    return m

# TRITIUM-PSEUDO fn=mmog_tick_rate_ok
#| fn mmog_tick_rate_ok(last_ms, now_ms, min_dt):
#|   return int(now_ms - last_ms >= min_dt)
# TRITIUM-HEIGHT fn=mmog_tick_rate_ok high=0.00 mid=1.00 low=0.00 role=leaf_charset
def mmog_tick_rate_ok(last_ms: int, now_ms: int, min_dt: int) -> int:
    return int(now_ms - last_ms >= min_dt)

# TRITIUM-PSEUDO fn=transform3d
#| fn transform3d(x, y, z, r00, r01, r02, r10, r11, r12, r20, r21, r22, tx, ty, tz, out):
#|   out[0] = r00 * x + r01 * y + r02 * z + tx
#|   out[1] = r10 * x + r11 * y + r12 * z + ty
#|   out[2] = r20 * x + r21 * y + r22 * z + tz
#|   return 1
# TRITIUM-HEIGHT fn=transform3d high=0.00 mid=0.27 low=0.73 role=algo_mid
def transform3d(x: float, y: float, z: float, r00: float, r01: float, r02: float, r10: float, r11: float, r12: float, r20: float, r21: float, r22: float, tx: float, ty: float, tz: float, out: list[float]) -> int:
    out[0] = r00 * x + r01 * y + r02 * z + tx
    out[1] = r10 * x + r11 * y + r12 * z + ty
    out[2] = r20 * x + r21 * y + r22 * z + tz
    return 1

# TRITIUM-PSEUDO fn=project3d
#| fn project3d(x, y, z, f, out):
#|   if z == 0.0:
#|     out[0] = 0.0
#|     out[1] = 0.0
#|     return 0
#|   out[0] = f * x / z
#|   out[1] = f * y / z
#|   return 1
# TRITIUM-HEIGHT fn=project3d high=0.00 mid=0.39 low=0.61 role=algo_mid
def project3d(x: float, y: float, z: float, f: float, out: list[float]) -> int:
    if z == 0.0:
        out[0] = 0.0
        out[1] = 0.0
        return 0
    out[0] = f * x / z
    out[1] = f * y / z
    return 1

# TRITIUM-PSEUDO fn=viewport
#| fn viewport(u, v, w, h, out):
#|   out[0] = (u + 1.0) * 0.5 * w
#|   out[1] = (1.0 - v) * 0.5 * h
#|   return 1
# TRITIUM-HEIGHT fn=viewport high=0.00 mid=0.25 low=0.75 role=algo_mid
def viewport(u: float, v: float, w: float, h: float, out: list[float]) -> int:
    out[0] = (u + 1.0) * 0.5 * w
    out[1] = (1.0 - v) * 0.5 * h
    return 1