Problem:
Score : 500 points

Problem Statement

#nck {
width: 30px;
height: auto;
}

There are N computers and N sockets in a one-dimensional world.
The coordinate of the i-th computer is a_i, and the coordinate of the i-th socket is b_i.
It is guaranteed that these 2N coordinates are pairwise distinct.

Snuke wants to connect each computer to a socket using a cable.
Each socket can be connected to only one computer.

In how many ways can he minimize the total length of the cables?
Compute the answer modulo 10^9+7.

Constraints

1 ≤ N ≤ 10^5

0 ≤ a_i, b_i ≤ 10^9

The coordinates are integers.

The coordinates are pairwise distinct.

Input

The input is given from Standard Input in the following format:

N
a_1
:
a_N
b_1
:
b_N

Output

Print the number of ways to minimize the total length of the cables, modulo 10^9+7.

Sample Input 1

2
0
10
20
30

Sample Output 1

2

There are two optimal connections: 0-20, 10-30 and 0-30, 10-20.
In both connections the total length of the cables is 40.

Sample Input 2

3
3
10
8
7
12
5

Sample Output 2

1

Solution in C (Clang 3.8.0) (judge verdict: Accepted)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct elm {
    struct elm *next, *prev;
    int data;
} elm_t;

typedef struct {
    elm_t *front, *back;
} list_t;

void push_back(list_t *list, int data) {
    elm_t *e = malloc(sizeof(elm_t));
    elm_t *f = list->back->prev;
    e->next = f->next;
    e->prev = f;
    e->data = data;
    f->next = e;
    list->back->prev = e;
}

list_t *mklist() {
    list_t *l = malloc(sizeof(list_t));
    l->front = malloc(sizeof(elm_t));
    l->back = malloc(sizeof(elm_t));
    l->front->next = l->back;
    l->back->prev = l->front;
    return l;
}

int a[200000][2];

int cmp(const void *const key, const void *const memb) {
    return *(const int *) key - *(const int *) memb;
}

int main() {
    int n, p = 0;
    long long r = 1;
    scanf("%d", &n);
    for (int i = 0; i < n * 2; i++) {
        scanf("%d", &a[i][0]);
        a[i][1] = (i / n) * 2 - 1;
    }
    qsort(a, n * 2, sizeof(int) * 2, cmp);
    for (int i = 0; i < n * 2; i++) {
        if (p * a[i][1] < 0) r = (r * abs(p)) % 1000000007;
        p += a[i][1];
    }
    printf("%lld\n", r);
}