Problem: <!--

Problem D

-->

Tally Counters

A number of tally counters are placed in a row. Pushing the button on a counter will increment the displayed value by one, or, when the value is already the maximum, it goes down to one. All the counters are of the same model with the same maximum value.

<image> Fig. D-1 Tally Counters

Starting from the values initially displayed on each of the counters, you want to change all the displayed values to target values specified for each. As you don't want the hassle, however, of pushing buttons of many counters one be one, you devised a special tool. Using the tool, you can push buttons of one or more adjacent counters, one push for each, in a single operation. You can choose an arbitrary number of counters at any position in each operation, as far as they are consecutively lined up.

How many operations are required at least to change the displayed values on counters to the target values?

Input

The input consists of multiple datasets, each in the following format.

> n m
>  a1 a2 ... an
>  b1 b2 ... bn
>

Each dataset consists of 3 lines. The first line contains n (1 ≤ n ≤ 1000) and m (1 ≤ m ≤ 10000), the number of counters and the maximum value displayed on counters, respectively. The second line contains the initial values on counters, ai (1 ≤ ai ≤ m), separated by spaces. The third line contains the target values on counters, bi (1 ≤ bi ≤ m), separated by spaces.

The end of the input is indicated by a line containing two zeros. The number of datasets does not exceed 100.

Output

For each dataset, print in a line the minimum number of operations required to make all of the counters display the target values.

Sample Input


4 5
2 3 1 4
2 5 5 2
3 100
1 10 100
1 10 100
5 10000
4971 7482 1238 8523 1823
3287 9013 9812 297 1809
0 0


Output for the Sample Input


4
0
14731






Example

Input

4 5
2 3 1 4
2 5 5 2
3 100
1 10 100
1 10 100
5 10000
4971 7482 1238 8523 1823
3287 9013 9812 297 1809
0 0


Output

4
0
14731

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <climits>
#include <iomanip>
#include <algorithm>
#include <queue>
#include <map>
#include <tuple>
#include <iostream>
#include <deque>
#include <array>
#include <set>
#include <functional>
#include <memory>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <numeric>
int solve(const int max, const std::vector<int>& counter, const std::vector<int>& target, const int counter_pos, const int overflow, std::vector<std::vector<int>>& memo) {
	if (counter_pos == 0) {
		return solve(max, counter, target, counter_pos + 1, 0, memo) + (target[0] - counter[0] + max) % max;
	}
	else if (counter_pos == counter.size()) {
		return 0;
	}
	else if (memo[counter_pos][overflow] >= 0) {
		return memo[counter_pos][overflow];
	}
	else {
		auto prev = (target[counter_pos - 1] - counter[counter_pos - 1] + max) % max;
		auto temp = (counter[counter_pos] + prev) % max;
		memo[counter_pos][overflow] = solve(max, counter, target, counter_pos + 1, (prev + (target[counter_pos] - temp + max) % max >= max) ? overflow + 1 : overflow, memo) + (target[counter_pos] - temp + max) % max;
		if ((target[counter_pos] - counter[counter_pos] + max) % max <= prev) {
			memo[counter_pos][overflow] = std::min(memo[counter_pos][overflow], solve(max, counter, target, counter_pos + 1, overflow, memo));
		}
		if (overflow > 0) {
			memo[counter_pos][overflow] = std::min(memo[counter_pos][overflow], solve(max, counter, target, counter_pos + 1, overflow - 1, memo));
		}
		return memo[counter_pos][overflow];
	}
}
int main() {
	while (true) {
		int n, m; std::cin >> n >> m;
		if (n == 0) break;
		std::vector<int>counter(n); for (auto& a : counter) std::cin >> a;
		std::vector<int>target(n); for (auto& b : target) std::cin >> b;
		std::vector<std::vector<int>> memo(n, std::vector<int>(n, -1));
		std::cout << solve(m, counter, target, 0, 0, memo) << std::endl;
	}
}