391_F1. Stock Trading
This problem consists of three subproblems: for solving subproblem F1 you will receive 8 points, for solving subproblem F2 you will receive 15 points, and for solving subproblem F3 you will receive 10 points.

Manao has developed a model to predict the stock price of a company over the next n days and wants to design a profit-maximizing trading algorithm to make use of these predictions. Unfortunately, Manao's trading account has the following restrictions: 

  * It only allows owning either zero or one shares of stock at a time; 
  * It only allows buying or selling a share of this stock once per day; 
  * It allows a maximum of k buy orders over the next n days; 



For the purposes of this problem, we define a trade to a be the act of buying one share of stock on day i, then holding the stock until some day j > i at which point the share is sold. To restate the above constraints, Manao is permitted to make at most k non-overlapping trades during the course of an n-day trading period for which Manao's model has predictions about the stock price.

Even though these restrictions limit the amount of profit Manao can make compared to what would be achievable with an unlimited number of trades or the ability to hold more than one share at a time, Manao still has the potential to make a lot of money because Manao's model perfectly predicts the daily price of the stock. For example, using this model, Manao could wait until the price is low, then buy one share and hold until the price reaches a high value, then sell for a profit, and repeat this process up to k times until n days have passed.

Nevertheless, Manao is not satisfied by having a merely good trading algorithm, and wants to develop an optimal strategy for trading subject to these constraints. Help Manao achieve this goal by writing a program that will determine when to buy and sell stock to achieve the greatest possible profit during the n-day trading period subject to the above constraints.

Input

The first line contains two integers n and k, separated by a single space, with <image>. The i-th of the following n lines contains a single integer pi (0 ≤ pi ≤ 1012), where pi represents the price at which someone can either buy or sell one share of stock on day i.

The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.

  * In subproblem F1 (8 points), n will be between 1 and 3000, inclusive. 
  * In subproblem F2 (15 points), n will be between 1 and 100000, inclusive. 
  * In subproblem F3 (10 points), n will be between 1 and 4000000, inclusive. 

Output

For this problem, the program will only report the amount of the optimal profit, rather than a list of trades that can achieve this profit.

Therefore, the program should print one line containing a single integer, the maximum profit Manao can achieve over the next n days with the constraints of starting with no shares on the first day of trading, always owning either zero or one shares of stock, and buying at most k shares over the course of the n-day trading period.

Examples

Input

10 2
2
7
3
9
8
7
9
7
1
9


Output

15


Input

10 5
2
7
3
9
8
7
9
7
1
9


Output

21

Note

In the first example, the best trade overall is to buy at a price of 1 on day 9 and sell at a price of 9 on day 10 and the second best trade overall is to buy at a price of 2 on day 1 and sell at a price of 9 on day 4. Since these two trades do not overlap, both can be made and the profit is the sum of the profits of the two trades. Thus the trade strategy looks like this: 
    
    
      
    2    | 7    | 3    | 9    | 8    | 7    | 9    | 7    | 1    | 9  
    buy  |      |      | sell |      |      |      |      | buy  | sell  
    

The total profit is then (9 - 2) + (9 - 1) = 15.

In the second example, even though Manao is allowed up to 5 trades there are only 4 profitable trades available. Making a fifth trade would cost Manao money so he only makes the following 4: 
    
    
      
    2    | 7    | 3    | 9    | 8    | 7    | 9    | 7    | 1    | 9  
    buy  | sell | buy  | sell |      | buy  | sell |      | buy  | sell  
    

The total profit is then (7 - 2) + (9 - 3) + (9 - 7) + (9 - 1) = 21.
```python
import sys


ammount_prices, days_for_trading=map(int, input().split())
stonks=[]
for i in range (0, ammount_prices):
    price=int(sys.stdin.readline())
    stonks.append(price)

def get_max(days_for_trading, stonks):
    size_prices = len(stonks)
    if size_prices == 0 or size_prices == 1 or days_for_trading == 0:
        return 0
    if days_for_trading >= size_prices/2:
        profit = 0
        for i in range(size_prices-1):
            diff = stonks[i + 1] - stonks[i]
            if diff > 0:
                profit += diff
        return profit
    
    hold = days_for_trading * [float('-inf')]
    hold_prev = days_for_trading * [float('-inf')]
    release = days_for_trading * [float('-inf')]
    release_prev = days_for_trading * [float('-inf')]

    for price in stonks:
        for j in range(0, days_for_trading):
            if j == 0:
                hold[j] = max(-price, hold_prev[j])
            else:
                hold[j] = max(release_prev[j - 1] - price, hold_prev[j])
            release[j] = max(hold_prev[j] + price, release_prev[j])
        hold_prev = hold
        release_prev = release
    return release[-1]
 


print(get_max(days_for_trading, stonks))
```