# translate by gpt
import sys
import threading
def solve():
    input = sys.stdin.readline
    INF = 10**15

    n, s = map(int, input().split())
    assert 1 <= n <= 1000 and 1 <= s <= 1000

    x = list(map(int, input().split()))
    for i in range(n - 1):
        assert x[i + 1] > x[i]
    assert x[0] > 0 and x[-1] <= 1000
    assert s not in x

    w = list(map(int, input().split()))
    assert max(w) <= 1000 and min(w) > 0

    # prefix sum of weights
    sumw = [0] * (n + 1)
    for i in range(n):
        sumw[i + 1] = sumw[i] + w[i]

    # dp[l][r][k]
    # k = 0 : currently at x[l]
    # k = 1 : currently at x[r-1]
    dp = [[[INF, INF] for _ in range(n + 1)] for __ in range(n)]

    # initialization
    for i in range(n):
        cost = abs(x[i] - s) * sumw[n]
        dp[i][i + 1][0] = cost
        dp[i][i + 1][1] = cost

    # transitions
    for l in range(n - 1, -1, -1):
        for r in range(l + 1, n + 1):
            remaining = sumw[n] - (sumw[r] - sumw[l])

            # extend to the right
            if r < n:
                dp[l][r + 1][1] = min(
                    dp[l][r + 1][1],
                    dp[l][r][0] + remaining * abs(x[l] - x[r]),
                    dp[l][r][1] + remaining * abs(x[r - 1] - x[r])
                )

            # extend to the left
            if l > 0:
                dp[l - 1][r][0] = min(
                    dp[l - 1][r][0],
                    dp[l][r][0] + remaining * abs(x[l] - x[l - 1]),
                    dp[l][r][1] + remaining * abs(x[r - 1] - x[l - 1])
                )

    print(min(dp[0][n][0], dp[0][n][1]))


if __name__ == "__main__":
    solve()