// Slower C++ solution:
                            #include <bits/stdc++.h>

                            #include<iostream>

                            #include<cstdio>

                            #include<vector>

                            #include<queue>

                            #include<map>

                            #include<cstring>

                            #include<string>

                            #include <math.h>

                            #include<algorithm>

                        //    #include <boost/multiprecision/cpp_int.hpp>

                            #include<functional>

                     #define int long long

                            #define inf  1000000007

                            #define pa pair<int,int>

                            #define ll long long

                            #define pal pair<double,int>

                            #define ppa pair<pa,int>

                            #define ssa pair<string,int>

                            #define  mp make_pair

                            #define  pb push_back

                            #define EPS (1e-10)

                            #define equals(a,b) (fabs((a)-(b))<EPS)

                     

                            using namespace std;

                     //priority_queue<int, vector<int>, greater<int> > que;

                            class Point{

                            	public:

                            	double x,y;

                            	Point(double x=0,double y=0):x(x),y(y) {}

                            	Point operator + (Point p) {return Point(x+p.x,y+p.y);}

                            	Point operator - (Point p) {return Point(x-p.x,y-p.y);}

                            	Point operator * (double a) {return Point(x*a,y*a);}

                            	Point operator / (double a) {return Point(x/a,y/a);}

                            	double absv() {return sqrt(norm());}

                            	double norm() {return x*x+y*y;}

                            	bool operator < (const Point &p) const{

                            		return x != p.x ? x<p.x: y<p.y;

                            	}

                            	bool operator == (const Point &p) const{

                            		return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;

                            	}

                            };

                            typedef Point Vector;

                     

                            struct Segment{

                            Point p1,p2;

                            };

                     

                        double hen(Vector a){

                        if(fabs(a.x)<EPS && a.y>0) return acos(0);

                        else if(fabs(a.x)<EPS && a.y<0) return 3*acos(0);

                        else if(fabs(a.y)<EPS && a.x<0) return 2*acos(0);

                        else if(fabs(a.y)<EPS && a.x>0) return 0.0;

                        else if(a.y>0) return acos(a.x/a.absv());

                        else return 2*acos(0)+acos(-a.x/a.absv());

                     

                        }

                     

                string itos( int i ) {

                ostringstream s ;

                s << i ;

                return s.str() ;

                }

                 

                int gcd(int v,int b){

                	if(v>b) return gcd(b,v);

                	if(v==b) return b;

                	if(b%v==0) return v;

                	return gcd(v,b%v);

                }

                            double dot(Vector a,Vector b){

                            	return a.x*b.x+a.y*b.y;

                            }

                            double cross(Vector a,Vector b){

                            	return a.x*b.y-a.y*b.x;

                            }

                        

                double distans(double x1,double y1,double x2,double y2){

                	double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);

                	return sqrt(rr);

                	

                }





                         //----------------kokomade tenpure------------





int z[200020]={0},q[200020]={0};



int a[200020]={0};

signed main(){

int n,m;

cin>>n>>m;

	for(int i=1;i<=n;i++) cin>>a[i];

	int souwa=0;

	for(int i=1;i<n;i++){

		if(a[i]<a[i+1])souwa+=a[i+1]-a[i];

		else souwa += a[i+1]-a[i]+m;

	}

	

	for(int i=1;i<n;i++){

		int r=a[i],rr=a[i+1];

		if(r>rr) rr+=m;

		z[r+2]+=1;

		z[rr+1]+=-1;

		q[rr+1] -= (rr-r-1);

	}

	

	for(int i=1;i<200020;i++) z[i] += z[i-1];

	for(int i=0;i<200020;i++) z[i] += q[i];

	

	for(int i=1;i<200020;i++) z[i] += z[i-1];

	

	int ans=0;

	for(int i=1;i<=m;i++)ans=max(ans,z[i]+z[i+m]);

	cout<<souwa-ans<<endl;

	

//cout<<ans<<endl;

	return 0;

}






// Faster C++ solution for the same problem (measured speedup: 3.9319699076854526x):
   #include <bits/stdc++.h>

 

//    #include <boost/multiprecision/cpp_int.hpp>

 #define int long long

 #define inf  1000000007

 #define pa pair<int,int>

 #define ll long long

 #define pal pair<double,double>

 #define ppap pair<pa,int>

  #define PI 3.14159265358979323846

  #define paa pair<int,char>

  #define  mp make_pair

  #define  pb push_back

  #define EPS (1e-8)

                                          

    int dx[8]={0,1,0,-1,1,1,-1,-1};

    int dy[8]={1,0,-1,0,-1,1,1,-1};

                                            using namespace std;

                                   			class pa3{

                                            	public:

                                            	int x;

                                   				int y,z;

                                            	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}

                                            	bool operator < (const pa3 &p) const{

                                            		if(x!=p.x) return x<p.x;

                                            		if(y!=p.y) return y<p.y;

                                            		 return z<p.z;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                   				bool operator > (const pa3 &p) const{

                                            		if(x!=p.x) return x>p.x;

                                            		if(y!=p.y) return y>p.y;

                                            		 return z>p.z;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa3 &p) const{

                                            		return x==p.x && y==p.y && z==p.z;

                                            	}

                                            		bool operator != (const pa3 &p) const{

                                            			return !( x==p.x && y==p.y && z==p.z);

                                            	}

                                            

                                            };

                                            

                                            class pa4{

                                            	public:

                                            	int x;

                                            	int y,z,w;

                                            	pa4(int x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}

                                            	bool operator < (const pa4 &p) const{

                                            		if(x!=p.x) return x<p.x;

                                            		if(y!=p.y) return y<p.y;

                                            		if(z!=p.z)return z<p.z;

                                            		return w<p.w;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator > (const pa4 &p) const{

                                            		if(x!=p.x) return x>p.x;

                                            		if(y!=p.y) return y>p.y;

                                            		if(z!=p.z)return z>p.z;

                                            		return w>p.w;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa4 &p) const{

                                            		return x==p.x && y==p.y && z==p.z &&w==p.w;

                                            	}

                                            		

                                            

                                            };

                                            class pa2{

                                            	public:

                                            	int x,y;

                                            	pa2(int x=0,int y=0):x(x),y(y) {}

                                            	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}

                                            	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}

                                            	bool operator < (const pa2 &p) const{

                                            		return y != p.y ? y<p.y: x<p.x;

                                            	}

                                            	bool operator > (const pa2 &p) const{

                                            		return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa2 &p) const{

                                            		return abs(x-p.x)==0 && abs(y-p.y)==0;

                                            	}

                                            	bool operator != (const pa2 &p) const{

                                            		return !(abs(x-p.x)==0 && abs(y-p.y)==0);

                                            	}

                                            		

                                            

                                            };

                                            

 

                      

                                string itos( int i ) {

                                ostringstream s ;

                                s << i ;

                                return s.str() ;

                                }

                                 

                                int gcd(int v,int b){

                                	if(v>b) return gcd(b,v);

                                	if(v==b) return b;

                                	if(b%v==0) return v;

                                	return gcd(v,b%v);

                                }

                 

                            

                                int mod;

int extgcd(int a, int b, int &x, int &y) {

    if (b == 0) {

        x = 1;

        y = 0;

        return a;

    }

    int d = extgcd(b, a%b, y, x);

    y -= a/b * x;

    return d;

}

pa operator+(const pa & l,const pa & r) {   

    return {l.first+r.first,l.second+r.second};                                    

}    

pa operator-(const pa & l,const pa & r) {   

    return {l.first-r.first,l.second-r.second};                                    

}  

                                

                int pr[1000010];

                int inv[1000010];

                

                int beki(int wa,int rr,int warukazu){

                	if(rr==0) return 1%warukazu;

                	if(rr==1) return wa%warukazu;

                	wa%=warukazu;

                	if(rr%2==1) return ((ll)beki(wa,rr-1,warukazu)*(ll)wa)%warukazu;

                	ll zx=beki(wa,rr/2,warukazu);

                	return (zx*zx)%warukazu;

                }

 

                

    			int comb(int nn,int rr){

    				if(rr<0 || rr>nn || nn<0) return 0;

    				int r=pr[nn]*inv[rr];

    				r%=mod;

    				r*=inv[nn-rr];

    				r%=mod;

    				return r;

    			}

               

                void gya(int ert){

                	pr[0]=1;

                	for(int i=1;i<=ert;i++){

                		pr[i]=(pr[i-1]*i)%mod;

                	}

                		inv[ert]=beki(pr[ert],mod-2,mod);

                	for(int i=ert-1;i>=0;i--){

                		inv[i]=inv[i+1]*(i+1)%mod;

                	}

                }

                

              //   cin.tie(0);

    		//	ios::sync_with_stdio(false);

    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            

                 //sort(ve.begin(),ve.end(),greater<int>());

 //   mt19937(clock_per_sec);

  //  mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;

      

       

       

                               //----------------kokomade tenpure------------





int imo[300020]={};

 signed main(){



   cin.tie(0);

	ios::sync_with_stdio(false);





 	int n,m;

 	cin>>n>>m;

 	

 	vector<int> ve(n);

 	for(int i=0;i<n;i++)cin>>ve[i];

 	int zen=0;

 	

 	for(int i=0;i<n-1;i++){

 		int a=ve[i],b=ve[i+1];

 		if(b<a) b+=m;

 		zen+=b-a;

 		if(b==a+1) continue;

 		imo[a+2]++;

 		imo[b+1]--;

 		

 	}

 	

 	for(int i=1;i<=2*m+10;i++)imo[i]+=imo[i-1];

 	

 	for(int i=0;i<n-1;i++){

 		int a=ve[i],b=ve[i+1];

 		if(b<a) b+=m;

 		if(b==a+1) continue;

 		//imo[a+2]++;

 		imo[b+1]-=b-a-1;

 	//	zen+=b-a;

 	}

 	

 	for(int i=1;i<=2*m+10;i++)imo[i]+=imo[i-1];

 	

 	for(int i=1;i<=m;i++){

 		imo[i]+=imo[i+m];

 	//	cout<<imo[i]<<endl;

 	}

 	int t=-1;

 	for(int i=1;i<=m;i++){

 		t=max(t,imo[i]);

 	}

 	cout<<zen-t<<endl;

 	

return 0;

 	

 

 }