let getButtonCounts (buttonA: Button) (buttonB: Button) buttonACost buttonBCost (prize:Prize) =
    // my way of trying to solve by moving the greatest axis first doesn't work for part 2.
    // everyone else seems to be using the slope between the two buttons and applying the cost
    // to a part. I don't see how it works but fuck it.
    // I had to add the `abs` calls to a and b to the borrow code, so who knows wtf. I'm done.
    let cpAB = crossProduct buttonA buttonB
    if cpAB = 0 then None
    else
        let detA = crossProduct prize buttonB
        let detB = crossProduct prize buttonA
        let struct(a, rem_a) = Int64.DivRem(detA, cpAB)
        let struct(b, rem_b) = Int64.DivRem(detB, cpAB)
        if (rem_a <> 0 || rem_b <> 0) then None
        else (abs(a) * (int64 buttonACost) + abs(b)) |> Some
    
    
    // here's where my code was. It came up short on part 2
    let (majorAxis:Point2<int64> -> int64), (minorAxis:Point2<int64> -> int64) = if prize.X > prize.Y then _.X, _.Y else _.Y,_.X
    let firstButton,firstCost, secondButton,secondCost =
        if majorAxis buttonA = majorAxis buttonB then (buttonB, buttonBCost, buttonA, buttonACost)
        else if majorAxis buttonA > majorAxis buttonB then (buttonA,buttonACost, buttonB,buttonBCost)
        else (buttonB, buttonBCost, buttonA, buttonACost)
    
    let origin:Point2<int64> = {X = 0; Y = 0}
    let toSlope button  = Segment.Slope.findL {Start = origin; End = button}
    
    let majorLine = (toSlope firstButton) |> fun s -> {Point = prize; Slope = s }
    let minorLine = (toSlope secondButton) |> fun s -> {Point = origin; Slope = s}
    
    let minorOffset = {Point = secondButton; Slope = minorLine.Slope }
    let intersection = Line.intersection majorLine minorOffset
                       |> Option.filter intersectsOnWholeNumber
                       // |> Option.filter (fun i -> i.X <= (float prize.X) && i.Y <= (float prize.Y)) // is in bounds
                       |> Option.map(fun p ->
                           let pp:Point2<int64> = {X = p.X |> round |> int64; Y = p.Y |> round |> int64}
                           pp)
                       // comparing by slopes can intersect outside of the bounds
                       // of the prize, which is not compatible
    
    match intersection with
    | None -> None
    | Some i -> 
        // steps to move to intersection
        let firstMovement =  (majorAxis prize - majorAxis i) / (majorAxis firstButton)
        // steps to move to 0
        let secondMovement = (minorAxis i) / (minorAxis secondButton)
        
        let cost = firstMovement * (int64 firstCost) + secondMovement * (int64 secondCost)
        Some cost

[ paste ]

from time import perf_counter_ns
import string

def profiler(method):
    def wrapper_method(*args: any, **kwargs: any) -> any:
        start_time = perf_counter_ns()
        ret = method(*args, **kwargs)
        stop_time = perf_counter_ns() - start_time
        time_len = min(9, ((len(str(stop_time))-1)//3)*3)
        time_conversion = {9: 'seconds', 6: 'milliseconds', 3: 'microseconds', 0: 'nanoseconds'}
        print(f"Method {method.__name__} took : {stop_time / (10**time_len)} {time_conversion[time_len]}")
        return ret

    return wrapper_method

@profiler
def main(input_data):
    part1_total_cost = 0
    part2_total_cost = 0
    for machine in input_data:
        Ax,Ay,Bx,By,Px,Py = [ int(l[2:]) for l in machine.split() if l[-1] in string.digits ]
        y,r = divmod((Ay * Px - Ax * Py), (Ay * Bx - Ax * By))
        if r == 0:
            x,r = divmod(Px - Bx * y, Ax)
            if r == 0:
                part1_total_cost += 3*x + y
        y,r = divmod((Ay * (Px+10000000000000) - Ax * (Py+10000000000000)), (Ay * Bx - Ax * By))
        if r == 0:
            x,r = divmod((Px+10000000000000) - Bx * y, Ax)
            if r == 0:
                part2_total_cost += 3*x + y

    return part1_total_cost,part2_total_cost

if __name__ == "__main__":
    with open('input', 'r') as f:
        input_data = f.read().strip().replace(',', '').split('\n\n')
    part_one, part_two = main(input_data)
    print(f"Part 1: {part_one}\nPart 2: {part_two}")