#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <random>
using namespace std;

long long solve(int L, int N, const vector<long long> &X, const vector<long long> &Y);

/**
 * 湖の周長: L <= 1e+9
 * 湖の周上にある木の本数: N　<= 2e+5
 * i本目の木の座標: 1 <= X[1] < ... < X[N] <= L-1
 * 
 * - 湖の周上には所有者の家がある．
 * - 周上は反時計回りに，家からの距離で実数の座標が定められている．
 * - 家のある座標 0 には木は生えていない．
 * 
 * 行動:
 * 	- すべての木を燃やし終えている場合，終了
 * 	- 時計回り(-)か反時計回り(+)かを指定
 * 	- 燃やしていない木がある座標まで指定した方向に歩き続ける
 * 	- 木があれば即ち燃やす
 * 
 * Q: 歩く距離の合計の最大値
 */
int main ()
{
	/**
	 * 解説の方法
	 * 
	 * - 初めの方向を順方向と逆方向で場合分け．
	 * - 以下，初めに順方向としたときについて．
	 * 	- 折り返し回数を固定するとき，初めはなるべく順方向に進んで，最後に繰り返し折り返すと最大長になる．
	 * 	- 折り返し回数は最大で N-1 回なので，時間計算量は O(N) （累積和などの方法で可能（後述））
	 */

	int L, N;
	cin >> L >> N;

	// 正の動径の経路
	vector<long long> X(N);
	// 負の動径の経路
	vector<long long> Y(N);

	for (int i=0; i<N; ++i)
	{
		cin >> X[i];
		Y[(N-1)-i] = L - X[i];
	}

	long long longest_route = max(solve(L, N, X, Y), solve(L, N, Y, X));
	cout << longest_route << endl;

	return 0;
}


// 順方向に対する解法
/**
 *   +--x-+ 
 *   x    | ↑ 順方向
 *   | 湖 o -L, 0, L
 *   |    | ↓ 逆方向
 *   +-x-x+
 * 
 * 湖の周上を次の直線で表すことにする．(o: 家，x: 木, N=4)
 * 
 *  -L                 0                 L
 *   o===x===x====x=x==o===x===x====x=x==o
 * 
 * この時，原点0の右側が順方向，左側が逆方向に向かうので，
 * 右側を「正の動径」，左側を「負の動径」と呼ぶことにする．
 * 
 * 正の動径について，すべての木を燃やすまでに移動する経路において，
 * 往路または復路に利用する可能性のある道は次からいくつか選んだものになる．
 * 次の道はそれぞれ，原点から木に向かう経路のうち，順方向のものである．
 * 
 *                                              0 1 2 3 |m: 折り返し回数
 *                                              --------+--------------
 *                     o===x                          2 | 通行回数
 *                     o=======x                    2 2 |
 *                     o============x             2 1   |
 *                     o==============x         1       |
 * 
 * 
 * 負の動径についても，すべての木を燃やすまでに移動する経路において，
 * 往路または復路に利用する可能性のある道は次からいくつか選んだものになる．
 * 次の道はそれぞれ，原点から木に向かう経路のうち，逆方向のものである．

 *                          0 1 2 3 |m: 折り返し回数
 *                          --------+--------------
 *                  x==o    0 1 2 2 | 通行回数
 *                x====o          1 |
 *           x=========o            |
 *       x=============o            |
 * 
 * 
 * 
 * さらに木の本数が増えたとき (N=9)，
 * 
 * - 正の動径について
 * 
 *   0 1 2 3 4 5 6 7 8 |m: 折り返し回数
 *  -------------------+--------------
 *                   2
 *                 2 2
 *               2 2 2
 *             2 2 2 2
 *           2 2 2 2 1
 *         2 2 2 1
 *       2 2 1
 *     2 1
 *   1
 * 
 * - 負の動径について
 * 
 *   0 1 2 3 4 5 6 7 8 |m: 折り返し回数
 *  -------------------+--------------
 *   0 1 2 2 2 2 2 2 2
 *         1 2 2 2 2 2
 *             1 2 2 2
 *                 1 2
 * 
 * という系列になることが予想される．
 * m=0 (初期値) から順に差分をとると，
 * 
 * - 正の動径について
 * 
 *   0 1 2 3 4 5 6 7 8 |m: 折り返し回数
 *  -------------------+--------------
 *                   2
 *                 2  
 *               2    
 *             2      
 *           2      -1
 *         2    -1-1
 *       2  -1-1
 *     2-1-1
 *   1-1
 * 
 * - 負の動径について
 * 
 *   0 1 2 3 4 5 6 7 8 |m: 折り返し回数
 *  -------------------+--------------
 *     1 1              
 *         1 1          
 *             1 1      
 *                 1 1  
 * 
 * となる．
 * 
 * 以上より，各mについての経路長の計算量は O(1) であり，
 * その中から最も長いものを答えとすれば良いので，
 * すべてのmについては O(N) で求めることができる．
 */

/**
 * 順方向に対する解法（AX, AY を入れ替えることで逆方向についても適用できる）
 * 
 * L: 湖の周長
 * N: 木の本数
 * X: 正の動径についての各経路 (X[i] = X[i])
 * Y: 負の動径についての各径路 (Y[i] = L - X[(N-1)-i])
 */
long long solve(int L, int N, const vector<long long> &X, const vector<long long> &Y)
{
	// 正の動径の経路
	long long positive_route = X[N-1];
	// 負の動径の経路
	long long negative_route = 0LL;

	// 最大長
	long long longest_route = positive_route + negative_route;

	// m: 折り返し回数
	for (int m=1; m<N; ++m)
	{
		positive_route -= X[(N-1) - (m/2)];
		positive_route += 2 * X[(N-1) - m];

		negative_route += Y[(m-1)/2];

		longest_route = max(positive_route + negative_route, longest_route);
	}

	return longest_route;
}


Measured memory_bytes: 3328