class Solution {

public:

    double findMedianSortedArrays(int A[], int m, int B[], int n)

    {

        // the following call is to make sure len(A) <= len(B).

        // yes, it calls itself, but at most once, shouldn't be

        // consider a recursive solution

        if (m > n)

            return findMedianSortedArrays(B, n, A, m);

        double ans = ;

        // now, do binary search

        int k = (n + m - ) / ;

        int l = , r = min(k, m); // r is n, NOT n-1, this is important!!

        while (l < r) {

            int midA = (l + r) / ;

            int midB = k - midA;

            if (A[midA] < B[midB])

                l = midA + ;

            else

                r = midA;

        }

        // after binary search, we almost get the median because it must be between

        // these 4 numbers: A[l-1], A[l], B[k-l], and B[k-l+1] 

        // if (n+m) is odd, the median is the larger one between A[l-1] and B[k-l].

        // and there are some corner cases we need to take care of.

        int a = max(l >  ? A[l - ] : -(<<), k - l >=  ? B[k - l] : -(<<));

        if (((n + m) & ) == )

            return (double) a;

        // if (n+m) is even, the median can be calculated by

        //      median = (max(A[l-1], B[k-l]) + min(A[l], B[k-l+1]) / 2.0

        // also, there are some corner cases to take care of.

        int b = min(l < m ? A[l] : (<<), k - l +  < n ? B[k - l + ] : (<<));

        return (a + b) / 2.0;

    }

};