#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <climits>
#include <cfloat>
#include <string>
#include <algorithm>
#include <vector>
#include <list>
#include <array>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <utility>
#include <iterator>

using namespace std;

#define endl "\n"

int t,n,m; vector<vector<int>> a; vector<int> b(4); bool flag,flag1,flag2;

void solve(){ //Your solution starts here.
	cin >> n >> m;
	a.clear(); //b.clear();
	for (int i=0;i<n;++i){
		for (int i=0;i<4;++i){
			cin >> b[i];
		}
		a.push_back(b);
	}
	if (m&1){
		cout << "NO" << endl; return;
	}
	flag1=flag2=flag=false;
	//if (m==4) flag=true;
	for (int i=0;i<n;++i){
		for (int j=i+1;j<n;++j){
			if (a[i][1]==a[j][2] && a[i][2]==a[j][1] && a[i][0]==a[j][0] && a[i][3]==a[j][3]){
				flag1=true;
			}
		}
	}
	for (int i=0;i<n;++i){
		if (a[i][1]==a[i][2]) flag2=true;
	}
	for (int i=0;i<n;++i){
		if (a[i][0]==a[i][3] && a[i][1]==a[i][2]) {
			flag=true; break;
		}
	}
	cout << (flag || (flag1&&flag2)? "YES" : "NO") << endl;
	return;
}
// you should actually read the stuff at the bottom
int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(NULL);
	#ifndef ONLINE_JUDGE
    	freopen("input.txt", "r", stdin);
    	freopen("error.txt", "w", stderr);
    	freopen("output.txt", "w", stdout);
	#endif
	cin >> t;
	while (t--)
	solve();
	cerr<<"time taken : "<<(float)clock()/CLOCKS_PER_SEC <<" secs"<<endl;
	return 0;
}

// read!read!read!read!read!read!read!read!read!
// ll vs. int!

/* stuff you should look for
    * int overflow, array bounds
    * special cases (n=1?)
    * do smth instead of nothing and stay organized
    * WRITE STUFF DOWN
    * DON'T GET STUCK ON ONE APPROACH
*/


#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <climits>
#include <cfloat>
#include <string>
#include <algorithm>
#include <vector>
#include <list>
#include <array>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <utility>
#include <iterator>

using namespace std;

#define endl "\n"

int t,n,m; vector<vector<int>> a; vector<int> b(4); bool flag,flag1,flag2;

void solve(){ //Your solution starts here.
	cin >> n >> m;
	a.clear(); //b.clear();
	for (int i=0;i<n;++i){
		for (int i=0;i<4;++i){
			cin >> b[i];
		}
		a.push_back(b);
	}
	if (m&1){
		cout << "NO" << endl; return;
	}
	flag1=flag2=flag=false;
	if (m==4) flag=true;
	for (int i=0;i<n;++i){
		for (int j=i+1;j<n;++j){
			if (a[i][1]==a[j][2] && a[i][2]==a[j][1] && a[i][0]==a[j][0] && a[i][3]==a[j][3]){
				flag1=true;
			}
		}
	}
	for (int i=0;i<n;++i){
		if (a[i][1]==a[i][2]) flag2=true;
	}
	for (int i=0;i<n;++i){
		if (a[i][0]==a[i][3] && a[i][1]==a[i][2]) {
			flag=true; break;
		}
	}
	cout << (flag || (flag1&&flag2)? "YES" : "NO") << endl;
	return;
}
// you should actually read the stuff at the bottom
int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(NULL);
	#ifndef ONLINE_JUDGE
    	freopen("input.txt", "r", stdin);
    	freopen("error.txt", "w", stderr);
    	freopen("output.txt", "w", stdout);
	#endif
	cin >> t;
	while (t--)
	solve();
	cerr<<"time taken : "<<(float)clock()/CLOCKS_PER_SEC <<" secs"<<endl;
	return 0;
}

// read!read!read!read!read!read!read!read!read!
// ll vs. int!

/* stuff you should look for
    * int overflow, array bounds
    * special cases (n=1?)
    * do smth instead of nothing and stay organized
    * WRITE STUFF DOWN
    * DON'T GET STUCK ON ONE APPROACH
*/


#include <bits/stdc++.h>
using namespace std;
#define lli long long int
int main()
{
  lli t,n,k;
  cin>>t;
  while(t--)
  {
      cin>>n>>k;
      bool flag=false;
      lli a,b,c,d,cnt=0;
      while(n--)
      {
          cin>>a>>b>>c>>d;
          if((b==c)&&(a==d))
          flag=true;
          if(b==c)
          cnt++;
      }
      if(k%2)
      cout<<"NO"<<endl;
      else if((k==2)&&cnt)
      cout<<"YES"<<endl;
      else if(k==2)
      cout<<"NO"<<endl;
      else if(!flag)
      cout<<"NO"<<endl;
      else
      cout<<"YES"<<endl;
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define lli long long int
int main()
{
  lli t,n,k;
  cin>>t;
  while(t--)
  {
      cin>>n>>k;
      bool flag=false;
      lli a,b,c,d;
      while(n--)
      {
          cin>>a>>b>>c>>d;
          if(a==d&&b==c)
          flag=true;
      }
      if(k%2)
      cout<<"NO"<<endl;
      else if(flag&&k==2)
      cout<<"YES"<<endl;
      else if(k==2)
      cout<<"NO"<<endl;
      else
      cout<<"YES"<<endl;
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define lli long long int
int main()
{
  lli t,n,k;
  cin>>t;
  while(t--)
  {
      cin>>n>>k;
      bool flag=false;
      lli a,b,c,d,cnt=0;
      while(n--)
      {
          cin>>a>>b>>c>>d;
          if(b==c)
          cnt++;
      }
      if(k%2)
      cout<<"NO"<<endl;
      else if(cnt)
      cout<<"YES"<<endl;
      else
      cout<<"NO"<<endl;
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define lli long long int
int main()
{
  lli t,n,k;
  cin>>t;
  while(t--)
  {
      cin>>n>>k;
      bool flag=false;
      lli a,b,c,d;
      while(n--)
      {
          cin>>a>>b>>c>>d;
          if(b==c)
          flag=true;
      }
      if(k%2)
      cout<<"NO"<<endl;
      else if(flag&&k==2)
      cout<<"YES"<<endl;
      else if(k==2)
      cout<<"NO"<<endl;
      else
      cout<<"YES"<<endl;
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define lli long long int
int main()
{
  lli t,n,k;
  cin>>t;
  while(t--)
  {
      cin>>n>>k;
      bool flag=false;
      lli a,b,c,d,cnt=0;
      while(n--)
      {
          cin>>a>>b>>c>>d;
          if((b==c)&&(a==d))
          flag=true;
          if(b==c)
          cnt++;
      }
      if(k%2)
      cout<<"NO"<<endl;
      else if(k==2&&cnt)
      cout<<"YES"<<endl;
      else if(!flag)
      cout<<"NO"<<endl;
      else
      cout<<"YES"<<endl;
  }
  return 0;
}


    /* Do it! */
    /*  OMAR  */
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

int main() {
    //o:
    int t, n, m;
    scanf("%i", &t);
    while(t--){
        bool isyes = false;
        scanf("%i%i", &n, &m);
        for (int i = 0, a, b, c, d; i < n; i++){
            scanf("%i%i%i%i", &a, &b, &c, &d);
            if(b == c)
                isyes = true;
        }
        if(m % 2 !=  0)
            isyes = false;

       printf(isyes ? "YES\n" : "NO\n");
    }

    //goto o;
    return 0;
}
/*
6
3 4
1 2
5 6
5 7
7 4
8 9
9 8
2 5
1 1
1 1
2 2
2 2
1 100
10 10
10 10
1 2
4 5
8 4
2 2
1 1
1 1
1 2
3 4
1 2
1 1
1 1
*/


    /* Do it! */
    /*  OMAR  */
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

int main() {
    //o:
    int t, n, m;
    scanf("%i", &t);
    while(t--){
        bool isyes = false;
       scanf("%i%i", &n, &m);
       for (int i = 0, a, b, c, d; i < n; i++){
           scanf("%i%i%i%i", &a, &b, &c, &d);
           if(b == c)
                isyes = true;
       }
        int sqr = sqrt(m);
        if(m != 2 && (sqr * sqr != m || sqr % 2 != 0))
            isyes = false;

       printf(isyes ? "YES\n" : "NO\n");
    }

    //goto o;
    return 0;
}
/*
6
3 4
1 2
5 6
5 7
7 4
8 9
9 8
2 5
1 1
1 1
2 2
2 2
1 100
10 10
10 10
1 2
4 5
8 4
2 2
1 1
1 1
1 2
3 4
1 2
1 1
1 1
*/


    /* Do it! */
    /*  OMAR  */
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

int main() {
    //o:
    int t, n, m;
    scanf("%i", &t);
    while(t--){
        map<pair<int, int>, pair<int, int>>ma;
        bool isd = false;
        bool isrd = false;
        scanf("%i%i", &n, &m);
        for (int i = 0, a, b, c, d; i < n; i++){
            scanf("%i%i%i%i", &a, &b, &c, &d);
            ma[make_pair(a, d)] = {b, c};
            if(ma[make_pair(a, d)].first == c && ma[make_pair(a, d)].second)
                isrd = true;
            if(b == c)
                isd = true;
        }
        int sqr = sqrt(m);
        if(m != 2 && (sqr * sqr != m || sqr % 2 != 0))
            isd = false;
        printf(isd && isrd ? "YES\n" : "NO\n");
    }
    //goto o;
    return 0;
}
/*
6
3 4
1 2
5 6
5 7
7 4
8 9
9 8
2 5
1 1
1 1
2 2
2 2
1 100
10 10
10 10
1 2
4 5
8 4
2 2
1 1
1 1
1 2
3 4
1 2
1 1
1 1
*/


    /* Do it! */
    /*  OMAR  */
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

int main() {
    //o:
    int t, n, m;
    scanf("%i", &t);
    while(t--){
        map<pair<int, int>, pair<int, int>>ma;
        bool isd = false;
        bool isrd = false;
        scanf("%i%i", &n, &m);
        for (int i = 0, a, b, c, d; i < n; i++){
            scanf("%i%i%i%i", &a, &b, &c, &d);

            ma[make_pair(a, d)] = {b, c};
//            cout<<ma[make_pair(a, d)].first <<" "<<c<<" "<<ma[make_pair(a, d)].second<<" "<<d<<endl;
            if(ma[make_pair(a, d)].first == c && ma[make_pair(a, d)].second == b)
                isrd = true;
            if(b == c)
                isd = true;
        }
        int sqr = sqrt(m);
        if(m != 2 && (sqr * sqr != m || sqr % 2 != 0))
            isd = false;
        if(m == 2)
            isrd = true;
        printf(isd && isrd ? "YES\n" : "NO\n");
    }
    //goto o;
    return 0;
}
/*
6
3 4
1 2
5 6
5 7
7 4
8 9
9 8
2 5
1 1
1 1
2 2
2 2
1 100
10 10
10 10
1 2
4 5
8 4
2 2
1 1
1 1
1 2
3 4
1 2
1 1
1 1
*/


    /* Do it! */
    /*  OMAR  */
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

int main() {
    //o:
    int t, n, m;
    scanf("%i", &t);
    while(t--){
        map<pair<int, int>, pair<int, int>>ma;
        bool isd = false;
        bool isrd = false;
        scanf("%i%i", &n, &m);
        for (int i = 0, a, b, c, d; i < n; i++){
            scanf("%i%i%i%i", &a, &b, &c, &d);

            ma[make_pair(a, d)] = {b, c};
            if(ma[make_pair(a, d)].first == c && ma[make_pair(a, d)].second == d)
                isrd = true;
            if(b == c)
                isd = true;
        }
        int sqr = sqrt(m);
        if(m != 2 && (sqr * sqr != m || sqr % 2 != 0))
            isd = false;
        if(m == 2)
            isrd = true;
        printf(isd && isrd ? "YES\n" : "NO\n");
    }
    //goto o;
    return 0;
}
/*
6
3 4
1 2
5 6
5 7
7 4
8 9
9 8
2 5
1 1
1 1
2 2
2 2
1 100
10 10
10 10
1 2
4 5
8 4
2 2
1 1
1 1
1 2
3 4
1 2
1 1
1 1
*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t){

        int n,m;
        cin>>n>>m;

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

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(y==a){
                yes=true;
            }
        }

        if((m*m)%2==1 || !yes){
            cout<<"NO"<<endl;
        }
        else{
            cout<<"YES"<<endl;
        }
    }

    return 0;
}

/*

*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t)
    {

        int n,m;
        cin>>n>>m;

        bool yo=false;
        int t1=0,t2=0;
        for(int i=1;i<=n;i++){

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(x==y && y==a && a==b){
                yo=true;
            }

            if(y==a && x==b){
                t1++;
            }
            else if(y==a){
                t2++;
            }
        }

        if((m*m)%2==1){
            cout<<"NO"<<endl;
            continue;
        }
        if(yo || (t1>0 && t2>0)){
            cout<<"YES"<<endl;
            continue;
        }

        cout<<"NO"<<endl;
    }

    return 0;
}

/*

*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t){

        int n,m;
        cin>>n>>m;

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

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(y==a){
                yes=true;
            }
        }

        if((m*m)%2==1 || !t2){
            cout<<"NO"<<endl;
        }
        else{
            cout<<"YES"<<endl;
        }
    }

    return 0;
}

/*

*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t)
    {

        int n,m;
        cin>>n>>m;

        // vector<vector<int> > v;
        bool yo=false;
        int p=0,q=0;
        for(int i=1;i<=n;i++){

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(x==y && y==a && a==b){
                yo=true;
            }
            if(y==a){
                if(x==b){
                    q++;
                }
                p++;
            }
        }

        if((m*m)%2==1){
            cout<<"NO"<<endl;
            continue;
        }
        if(yo || (p>=2 && q>0)){
            cout<<"YES"<<endl;
            continue;
        }

        cout<<"NO"<<endl;
    }

    return 0;
}

/*

*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t)
    {

        int n,m;
        cin>>n>>m;

        // vector<vector<int> > v;
        bool yo=false;
        int p=0;
        for(int i=1;i<=n;i++){

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(x==y && y==a && a==b){
                yo=true;
            }
            if(y==a){
                p++;
            }
            // v.pb({x,y,a,b})
        }

        if((m*m)%2==1){
            cout<<"NO"<<endl;
            continue;
        }
        if(yo || p>=2){
            cout<<"YES"<<endl;
            continue;
        }

        cout<<"NO"<<endl;
    }

    return 0;
}

/*

*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t)
    {

        int n,m;
        cin>>n>>m;

        bool yo=false;
        int t1=0,t2=0,t3=0,t4=0;
        for(int i=1;i<=n;i++){

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(x==y && y==a && a==b){
                yo=true;
            }

            if(y==a && x==b){
                t1++;
            }
            else if(y==a){
                t2++;
            }
            else if(x==b){
                t3++;
            }
        }

        if((m*m)%2==1){
            cout<<"NO"<<endl;
            continue;
        }
        if(yo || (t1>0 && t2>0) || (t1>0 && t3>0)){
            cout<<"YES"<<endl;
            continue;
        }

        cout<<"NO"<<endl;
    }

    return 0;
}

/*

*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t)
    {

        int n,m;
        cin>>n>>m;

        bool yo=false;
        int t1=0,t2=0,t3=0,t4=0;
        for(int i=1;i<=n;i++){

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(x==y && y==a && a==b){
                yo=true;
            }

            if(y==a && x==b){
                t1++;
            }
        }

        if((m*m)%2==1){
            cout<<"NO"<<endl;
            continue;
        }
        if(yo || t1>0){
            cout<<"YES"<<endl;
            continue;
        }

        cout<<"NO"<<endl;
    }

    return 0;
}

/*

*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t)
    {

        int n,m;
        cin>>n>>m;

        bool yo=false;
        int p=0,q=0,r=0,s=0;
        for(int i=1;i<=n;i++){

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(x==y && y==a && a==b){
                yo=true;
            }
            if(y==a){
                if(x==b){
                    q++;
                }
                p++;
            }
            if(x==b){
                if(y==a){
                    r++;
                }
                s++;
            }
        }

        if((m*m)%2==1){
            cout<<"NO"<<endl;
            continue;
        }
        if(yo || (p>=2 && q>0) || (s>=2 && r>=1)){
            cout<<"YES"<<endl;
            continue;
        }

        cout<<"NO"<<endl;
    }

    return 0;
}

/*

*/


// by VIDIT BHARDWAJ
#include<bits/stdc++.h>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;

// when we want to insert same element multiple times into pbds
// typedef tree<pair<int,int>,null_type,less<pair<int,int > >,rb_tree_tag,tree_order_statistics_node_update> pbds;

#define int                     long long int
#define pb                      push_back
// #define mk(a,n,pair<int,int>)   pair<int,int> *a=new pair<int,int>[n];
#define setbits(x)              __builtin_popcountll(x)
#define zerobits(x)             __builtin_ctzll(x)
#define ps(x,y)                 fixed<<setprecision(y)<<x // cout<<ps(1.255114,4)
#define max3(a,b,c)             max(max((a),(b)),(c))
#define max4(a,b,c,d)           max(max((a),(b)),max((c),(d)))
#define min3(a,b,c)             min(min((a),(b)),(c))
#define min4(a,b,c,d)           min(min((a),(b)),min((c),(d)))
#define tc(t)                   int t; cin>>t; while(t--)

const long long mod=1000000007;
const int inf=1000000000000000000;
const long double pi = 3.14159265358979323846264338;

bool double_compare(double a, double b, double epsilon = 0.001)
{
    return std::abs(a - b) < epsilon;
}
int lcm(int a,int b){
    return (a*b)/__gcd(a,b);
}
bool isPrime(int n)
{
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6){
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }

    return true;
}
// Fermat's little theorem
int pow(int a, unsigned int b,int mod1){

    int ans=1;
    while(b){

        if(b&1ll){

            ans*=a;
            ans%=mod1;
        }
        b/=2;
        a*=a;
        a%=mod1;
    }

    return ans;
}
int inverse(int a,int mod1){

    return pow(a,mod1-2,mod1);    // a^-1%p
}
///////////////////////////////////////////////////////////////////////////////////////////////////

signed main()
{
    tc(t)
    {

        int n,m;
        cin>>n>>m;

        bool yo=false;
        int t1=0,t2=0,t3=0,t4=0;
        for(int i=1;i<=n;i++){

            int x,y,a,b;
            cin>>x>>y>>a>>b;
            if(y==a){
                t2++;
            }
        }

        if((m*m)%2==1 || t2==0){
            cout<<"NO"<<endl;
            continue;
        }

        cout<<"YES"<<endl;
    }

    return 0;
}

/*

*/


#include<iostream>
using namespace std;

int main() {
 int t;
cin>>t;
while(t--)
{
int n,m,a=0,x0,x1,y0,y1;
cin>>n>>m;
for(int i=1;i<=n;i++)
{ cin>>x0>>x1>>y0>>y1;
 if(x1==y0)
a++;
}
if(a>0 && m%2==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}


#include<iostream>
using namespace std;

int main() {
 int t;
cin>>t;
while(t--)
{
int n,m,a=0,x0,x1,y0,y1;
cin>>n>>m;
for(int i=1;i<=n;i++)
{ cin>>x0>>x1>>y0>>y1;
 if(x0==y1 && x1==y0)
a++;
if(a>0)
i=n+1;
}
if(a>0 && m%2==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}


#include<iostream>
using namespace std;

int main() {
 int t;
cin>>t;
while(t--)
{
int n,m,a=0,ar[2],arr[2];
cin>>n>>m;
for(int i=1;i<=n;i++)
{ cin>>ar[0]>>ar[1]>>arr[0]>>arr[1];
 if(ar[0]==arr[1] && ar[1]==arr[0])
a++;
}
if(a>0 && m%n==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}


#include<iostream>
using namespace std;

int main() {
 int t;
cin>>t;
while(t--)
{
int n,m,a=0,ar[2],arr[2];
cin>>n>>m;
for(int i=1;i<=n;i++)
{ cin>>ar[0]>>ar[1]>>arr[0]>>arr[1];
 if(ar[0]==arr[1] && ar[1]==arr[0])
a++;
}
if(a>0 && m%2==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}


#include<iostream>
using namespace std;

int main() {
 int t;
cin>>t;
while(t--)
{
int n,m,a=0,x0,x1,y0,y1;
cin>>n>>m;
for(int i=1;i<=n;i++)
{ cin>>x0>>x1>>y0>>y1;
 if(x0==y1 && x1==y0)
a++;
if(a>0)
break;
}
if(a>0 && m%2==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}


#include<iostream>
using namespace std;

int main() {
 int t;
cin>>t;
while(t--)
{
int n,m,a=0,x0,x1,y0,y1;
cin>>n>>m;
for(int i=1;i<=n;i++)
{ cin>>x0>>x1>>y0>>y1;
 if(x0==y1 && x1==y0)
a++;
}
if(a>0 && m%2==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}


#include<iostream>
using namespace std;

int main() {
 int t;
cin>>t;
while(t--)
{
int n,m,a=0,x0,x1,y0,y1;
cin>>n>>m;
for(int i=1;i<=n;i++)
{ cin>>x0>>x1>>y0>>y1;
 if(x1==y0)
a++;
if(a>0)
i=n+1;
}
if(a>0 && m%2==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}


#include<iostream>
using namespace std;

int main() {
 int t;
cin>>t;
while(t--)
{
int n,m,a=0,ar[2],arr[2];
cin>>n>>m;
for(int i=1;i<=2*n;i++)
{ for(int j=0;j<2;j++)
  cin>>ar[j];
for(int k=0;k<2;k++)
cin>>arr[k];
 if(ar[0]==arr[1] &&ar[1]==arr[0])
a++;
}
if(a>0 && m%n==0)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}


#include <iostream>
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define N 1000000007

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	ll t;
	cin >> t;
	while (t--)
	{
		ll n, m, sym = 0;
		cin >> n >> m;

		for (ll i = 0; i < n; i++)
		{
			ll a, b, c, d;
			cin >> a >> b >> c >> d;
			if (b == c)sym++;
		}
		if (m % 2 == 1 || sym == 0 || m == 0) cout << "NO" << endl;
		else if (m % 2 == 0 && sym >= 1)cout << "YES" << endl;

	}

	return 0;
}


#include <iostream>
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define N 1000000007

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	ll t;
	cin >> t;
	while (t--)
	{
		ll n, m, sym = 0;
		cin >> n >> m;

		for (ll i = 0; i < n; i++)
		{
			ll a, b, c, d;
			cin >> a >> b >> c >> d;
			if (a == d && b == c)sym++;
		}
		if (m % 2 == 1 || sym == 0 || m == 0) cout << "NO" << endl;
		else if (m % 2 == 0 || sym >= 1)cout << "YES" << endl;

	}

	return 0;
}


#include <iostream>
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define N 1000000007

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	ll t;
	cin >> t;
	while (t--)
	{
		ll n, m, sym = 0;
		cin >> n >> m;

		for (ll i = 0; i < n; i++)
		{
			ll a, b, c, d;
			cin >> a >> b >> c >> d;
			if (a == d && b == c)sym = 1;
		}

		if (m % 2 == 0 && sym == 1)cout << "YES" << endl;
		else cout << "NO" << endl;
	}

	return 0;
}


a=int(input())
l=1
r=a
ans=[1]
while(len(ans)!=a):
    i=len(ans)
    if(i%2==1):
        ans.append(r)
        r-=1
    else:
        ans.append(l+1)
        l+=1
print(*ans)


import time,math as mt,bisect as bs,sys
from sys import stdin,stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
pi=3.14159265358979323846264338327950
def II(): # to take integer input
    return int(stdin.readline())
def IO(): # to take string input
    return stdin.readline()
def IP(): # to take tuple as input
    return map(int,stdin.readline().split())
def L(): # to take list as input
    return list(map(int,stdin.readline().split()))
def P(x): # to print integer,list,string etc..
    return stdout.write(str(x)+"\n")
def PI(x,y): # to print tuple separatedly
    return stdout.write(str(x)+" "+str(y)+"\n")
def lcm(a,b): # to calculate lcm
    return (a*b)//gcd(a,b)
def gcd(a,b): # to calculate gcd
    if a==0:
        return b
    elif b==0:
        return a
    if a>b:
        return gcd(a%b,b)
    else:
        return gcd(a,b%a)
def readTree(): # to read tree
    v=int(input())
    adj=[set() for i in range(v+1)]
    for i in range(v-1):
        u1,u2=In()
        adj[u1].add(u2)
        adj[u2].add(u1)
    return adj,v
def bfs(adj,v): # a schema of bfs
    visited=[False]*(v+1)
    q=deque()
    while q:
        pass
def sieve():
    li=[True]*1000001
    li[0],li[1]=False,False
    for i in range(2,len(li),1):
        if li[i]==True:
            for j in range(i*i,len(li),i):
                li[j]=False
    prime=[]
    for i in range(1000001):
        if li[i]==True:
            prime.append(i)
    return prime
def setBit(n):
    count=0
    while n!=0:
        n=n&(n-1)
        count+=1
    return count
mx=10**7
spf=[mx]*(mx+1)
def SPF():
    spf[1]=1
    for i in range(2,mx+1):
        if spf[i]==mx:
            spf[i]=i
            for j in range(i*i,mx+1,i):
                if i<spf[j]:
                    spf[j]=i
    return
#####################################################################################
mod=10**9+7
def solve():
    n=II()
    diff=(n-1)
    curr=1
    print(curr,end=" ")
    while abs(diff)>=1:
        curr+=diff
        print(curr,end=" ")
        if diff>0:
            diff=-1*(abs(diff)-1)
        else:
            diff=abs(diff)-1

    return

t=1
for i in range(t):
    solve()

    #######
   #
  #
 #######   #     #  # ####   # #     #
       #  # #   #  # #   #  # # #   #
      #  ####  #  # ####   ####  # #
######  #   # #### #    # #   #   #


import sys
from array import array  # noqa: F401

def input():
    return sys.stdin.buffer.readline().decode('utf-8')

n = int(input())
if n == 1:
    print(1)
    exit()

a = [1, n]
ans = [1]

while abs(a[0] - a[1]) > 0:
    ans.append(a[1])
    if a[0] < a[1]:
        a[0] += 1
    else:
        a[0] -= 1
    a[0], a[1] = a[1], a[0]

print(*ans)


n=int(input())
l=list(range(1,n+1))
a=[]
start=0
end=len(l)-1
while(len(a)<len(l)):
    a.append(l[start])
    a.append(l[end])
    start=start+1
    end=end-1
if(len(l)%2!=0):
    a=a[0:len(a)-1]
print(*a)


# import atexit
# import io
# import sys
#
# _INPUT_LINES = sys.stdin.read().splitlines()
# input = iter(_INPUT_LINES).__next__
# _OUTPUT_BUFFER = io.StringIO()
# sys.stdout = _OUTPUT_BUFFER
#
#
# @atexit.register
# def write():
#     sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())

n = int(input())

res = []

isLeft = True

for _ in range(n):
    if isLeft:
        res.append(_ // 2 + 1)
        isLeft = False
    else:
        res.append(n - _ // 2)
        isLeft = True

print(*res)


n = int(input())
for i in range(int(n/2)):
	print(i+1,n-i,end = " ")
if n%2 != 0:
	print(int(n/2)+1)


#pragma GCC optimize("Ofast,vpt,unroll-loops,shrink-wrap-separate,loop-nest-optimize")

#include <bits/stdc++.h>
// #include <tr1/unordered_map>
// #include <ext/rope>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/trie_policy.hpp>
// #include <ext/pb_ds/tree_policy.hpp>

#define mt make_tuple
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define mat vector<vector<ll>>
#define vi vector<int>
#define vll vector<ll>
#define psi pair<string, int>
#define pis pair<int, string>
#define pic pair<int, char>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define piiii pair<pii, pii>
#define mii map<int, int>
#define umii tr1::unordered_map<int, int>
#define iter map<int, int>::iterator
#define lb lower_bound
#define ub upper_bound

#define fi first
#define se second

/*
#define piii pair<int, pii>
#define fi first
#define se second.fi
#define th second.second
*/

/*
#define piii pair<pii, int>
#define fi first.first
#define se first.th
#define th second
*/

#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()

using namespace std;
// using namespace __gnu_cxx;
// using namespace __gnu_pbds;

typedef long long ll;
typedef long double ld;
// typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ost;

const int nax = 100005, lgax = 24, bit = 31, mod = 1000000009, inf = 1000000007;
const ll llax = 9e18;
const ld pi = 3.14159265358979323846, eps = 1e-4;

mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());

inline int read() {
	char c = getchar_unlocked();
	int t = 0, f = 1;
	while ((c < '0' || '9' < c) && c != EOF)
		f = (c == '-' ? -1 : 1), c = getchar_unlocked();
	while (('0' <= c && c <= '9') && c != EOF)
	t = t * 10 + c - '0', c = getchar_unlocked();
	return t * f;
}

struct chash {
    static uint64_t splitmix64(uint64_t x)
    {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }
    size_t operator()(uint64_t x) const
    {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

ll layer = 1, dp[11][nax], w[nax], pref[nax], tmp[nax], n, k;

void rec(int low, int high, int l, int r) {
	if (low > high)
		return;
	int m = (low + high) >> 1, opt = -1;
	ll c;
	for (int i = min(r, m - 1); i >= l; --i) {
		c = tmp[m] - tmp[i] - (i + 1) * (pref[m] - pref[i]);
		if (dp[layer][m] >= dp[layer - 1][i] + c)
			dp[layer][m] = dp[layer - 1][i] + c, opt = i;
	}
	if (layer == 1)
		dp[1][m]= tmp[m];
	rec(low, m - 1, l, opt), rec(m + 1, high, opt, r);
}

int main() {
	n = read(), k = read();
	for (int i = 0; i < n; ++i)
		w[i] = read();
	pref[0] = w[0];
	for (int i = 1; i < n; ++i)
		pref[i] = pref[i - 1] + w[i], tmp[i] = tmp[i - 1] + w[i] * i;
	for (int i = 0; i <= k; ++i)
		for (int j = 0; j < n; ++j)
			dp[i][j] = llax;
	for (; layer <= k; ++layer)
		rec(0, n - 1, 0, n - 1);
	printf("%lld", dp[k][n - 1]);
    return 0;
}


from sys import stdin
input = stdin.buffer.readline

n = int(input())
k, c = (n + 1) >> 1, 0
while k + c > 0 and k + c <= n:
	print(k + c)
	k += c
	if c > 0:
		c += 1
	else:
		c -= 1
	c *= -1


def main():
    n = int(input())
    if n < 2:
        print('1')
    elif n < 3:
        print('1 2')
    elif n < 4:
        print('1 3 2')
    else:
        print('1 3 2', end=' ')
        a = 2
        while True:
            b = a + 3
            c = a + 2
            if b < n:
                print(f'{b} {c}', end=' ')
                a = c
            elif b == n:
                print(f'{b} {c}')
                break
            elif c == n:
                print(f'{c}')
                break

main()


def main():
    t = int(input())
    l = 1
    r = t
    while l < r:
        print(f'{l} {r}', end=' ')
        l += 1
        r -= 1
    else:
        if l == r:
            print(f'{l}')

main()


def main():
    n = int(input())
    l = 1
    r = n
    while l < r:
        print(f'{l} {r}', end=' ')
        l += 1
        r -= 1
    else:
        if l == r:
            print(f'{l}')

main()


#------------------------template--------------------------#
import os
import sys
# from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=10**9+7
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]

#-------------------------code---------------------------#
# vsInput()

n=Int()

low=1
high=n

while(low<high):

    print(low,high,end=" ")
    low+=1
    high-=1

if(low==high): print(low)


import math
import itertools
import collections

def getdict(n):
    d = {}
    if type(n) is list:
        for i in n:
            if i in d:
                d[i] += 1
            else:
                d[i] = 1
    else:
        for i in range(n):
            t = ii()
            if t in d:
                d[t] += 1
            else:
                d[t] = 1
    return d
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a*b) // math.gcd(a, b)
def prime(n):
    if n == 2:
        return True
    if n % 2 == 0 or n <= 1:
        return False

    sqr = int(math.sqrt(n)) + 1

    for d in range(3, sqr, 2):
        if n % d == 0:
            return False
    return True

def rev(n):
    m = 0
    while n > 0:
        m = m * 10 + n % 10
        n = n // 10
    return m

n = ii()
ans = [1]
t = n - 1
for i in range(n - 1):
    ans.append(ans[i] + t * (-1) ** i)
    t -= 1
print(' '.join(map(str, ans)))


import math
import itertools
import collections

def getdict(n):
    d = {}
    if type(n) is list:
        for i in n:
            if i in d:
                d[i] += 1
            else:
                d[i] = 1
    else:
        for i in range(n):
            t = ii()
            if t in d:
                d[t] += 1
            else:
                d[t] = 1
    return d
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a*b) // math.gcd(a, b)
def prime(n):
    if n == 2:
        return True
    if n % 2 == 0 or n <= 1:
        return False

    sqr = int(math.sqrt(n)) + 1

    for d in range(3, sqr, 2):
        if n % d == 0:
            return False
    return True

def rev(n):
    m = 0
    while n > 0:
        m = m * 10 + n % 10
        n = n // 10
    return m

n = ii()
l = [i for i in range(1, n + 1, 2)]
r = [i for i in range((n // 2) * 2, 0, -2)]
l.extend(r)
print(' '.join(map(str, l)))


import os
import sys
from io import BytesIO, IOBase

def main():
    pass

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def binary(n):
    return (bin(n).replace("0b", ""))

def decimal(s):
    return (int(s, 2))

def pow2(n):
    p = 0
    while (n > 1):
        n //= 2
        p += 1
    return (p)

def isPrime(n):
    if (n == 1):
        return (False)
    else:
        root = int(n ** 0.5)
        root += 1
        for i in range(2, root):
            if (n % i == 0):
                return (False)
        return (True)
n=int(input())
f=1
r=n
for i in range(0,n):
    if(i%2==0):
        print(f,end=" ")
        f+=1
    else:
        print(r,end=" ")
        r-=1


n=int(input())
a=[]
large=n
small=1
for i in range(n):
    if i%2==0:
        a.append(large)
        large-=1
    else:
        a.append(small)
        small+=1
print(*a)


N = int( input() )
ans = [ 1 ]
for i in range( 1, N, 1 ):
  if len( ans ) & 1:
    ans.append( ans[ len( ans ) - 1 ] + ( N - i ) )
  else:
    ans.append( ans[ len( ans ) - 1 ] - ( N - i ) )
print( * ans )


n=int(input())
for i in range(1,(n//2+1)):
    print(i,n-i+1,end=' ')
if(n%2==1):
    print(n//2+1)
print()


n=int(input())
for i in range(1,1+n):
    print(i,end=' ')


import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7

n = int(ri())
l = 1
r=  n
arr = [l,r]
turn = 0
l+=1
r-=1
while l <= r:
    if turn == 1:
        arr.append(r)
        r-=1
    else:
        arr.append(l)
        l+=1
    turn^=1
print(*arr)


import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7

n = int(ri())
l = 1
r=  n
if n == 1:
    print(1)
else:
    arr = [l,r]
    turn = 0
    l+=1
    r-=1
    while l <= r:
        if turn == 1:
            arr.append(r)
            r-=1
        else:
            arr.append(l)
            l+=1
        turn^=1
    print(*arr)


import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7

n = int(ri())
l = 1
r=  n
arr = [l,r]
turn = 0
l+=1
r-=1
while l <= r:
    if turn == 0:
        arr.append(r)
        r-=1
    else:
        arr.append(l)
        l+=1
    turn^=1
print(*arr)


n = int(input())
x = 1
y = n
while 1:
    if x > n // 2:
        if n % 2: print(x)
        break
    print(x, y, end = " ")
    x += 1
    y -= 1


from collections import Counter
if __name__ == '__main__':
	n = int(input())
	curr = 1
	dirc = 1
	print(curr, end = " ")
	for jump in range(n-1,0,-1):
		curr = curr+dirc*jump
		print(curr, end = " ")
		dirc *= -1


n = int(input())
strs = ""

for i in range(n):
    i += 1
    strs += str(i)
    strs += " "

print(strs[:-1])


n = int(input())
strs = "1 "
prev = 1
curdiff = n - 1
dicts = {}
dicts[1] = 1
for i in range(n):
    if i == 0 :
        continue
    newnum = prev + curdiff
    if newnum > n or newnum in dicts :
        newnum = prev - curdiff
    dicts[newnum] = 1
    prev = newnum
    curdiff -= 1
    strs += str(newnum)
    strs += " "

print(strs[:-1])


n=int(input())
arr=[]
for i in range(1,n+1):
    arr.append(i)
l=0
r=n-1
t=1
while(l<=r):
    if t%2==1:
        t+=1
        print(arr[l],end=" ")
        l+=1
    else:
        t+=1
        print(arr[r],end=" ")
        r-=1


n=int(input())
a=[0]*n
i=1
j=n
for z in range(n):
    print(i,end=' ')
    i+=1
    if i>j:break
    print(j,end=' ')
    j-=1
    if i>j:break


n=int(input())
a=[0]*n
i=0
j=n-1
t=1
while i<=j:
    a[i]=t
    i+=1
    t+=1
    if i>j:break
    a[j]=t
    j-=1
    t+=1
for i in a:
    print(i,end=' ')


#53C
n = int(input())
ans = []
for i in range(n):
    ans.append(i+1)
res = ans[::2] + ans[1::2]
print(*res)


#53C
n = int(input())
for i in range(n):
    print(i//2 + 1 if i%2 == 0 else n - i//2, end= " ")


#53C
for i in range(int(input())):
    print(i//2 + 1 if i%2 == 0 else n - i//2, end= " ")


#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;

int main() {
    ll n, k;
    cin >> n >> k;
    ll S = k*(k+1)/2;
    if(k*(k+1)/2 > n || (k <= 40 && (1LL << k)-1 < n)) return puts("NO"), 0;
    vector<ll> v(k);
    iota(v.begin(),v.end(), 1);
    int cur = k-1;
    while(S < n){
        ll x = min(n-S, v[cur-1]*2-v[cur]);
        S += x;
        v[cur] += x;
        cur--;
        if(cur == 0) cur = k-1;
    }
    puts("YES");
    for (int i = 0; i < k; ++i) {
        if(i) printf(" ");
        printf("%lld", v[i]);
    }
    puts("");
    return 0;
}


#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;

int main() {
    ll n, k;
    cin >> n >> k;
    ll S = k*(k+1)/2;
    if(k*(k+1)/2 > n) return puts("NO"), 0;
    vector<ll> v(k);
    iota(v.begin(),v.end(), 1);
    int cur = k-1;
    while(S < n){
        ll x = min(n-S, v[cur-1]*2-v[cur]);
        S += x;
        v[cur] += x;
        cur--;
        if(cur == 0) {
            x = min(n-S, v[1]-v[0]);
            S += x;
            v[cur] += x;
        }
    }
    puts("YES");
    for (int i = 0; i < k; ++i) {
        if(i) printf(" ");
        printf("%lld", v[i]);
    }
    puts("");
    return 0;
}


#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;

int main() {
    ll n, k;
    cin >> n >> k;
    ll S = k*(k+1)/2;
    if(k*(k+1)/2 > n) return puts("NO"), 0;
    vector<ll> v(k);
    iota(v.begin(),v.end(), 1+(n-S)/k);
    S += (n-S)/k*k;
    while(S < n){
        int ok = 0;
        for (int i = k-2; S < n && i >= 0; --i) {
            while(v[i]*2 > v[i+1]) v[i+1]++, S++, ok = 1;
        }
        if(!ok) return puts("NO"), 0;
    }
    puts("YES");
    for (int i = 0; i < k; ++i) {
        if(i) printf(" ");
        printf("%lld", v[i]);
    }
    puts("");
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n, k;
    cin >> n >> k;
    int i;
    int m = (k * (k + 1)) / 2;
    int flag = 0;
    int a[k];
    for (i = 0; i < k; i++)
    {
        a[i] = i + 1;
    }
    if (n < m)
    {
        cout << "NO" << endl;
    }
    else
    {
        int t = n - m;
        //cout<<"t is .."<<t<<endl;
        int fl = 0;
        while (t > 0)
        {
            t -= k;
            fl++;
        }
        if (fl == 0)
        {
            fl = 0;
        }
        else
        {
            if(t!=0){
                fl--;
                t += k;
            }
        }
        //cout << "t is " << t << endl;
        //cout << "fl is " << fl << endl;
        for (i = 0; i < k; i++)
        {
            a[i] += fl;
        }
        // for (i = 0; i < k; i++)
        // {
        //     cout<<a[i]<<endl;
        // }
        if (t == 0)
        {
            cout << "YES" << endl;
            for (i = 0; i < k; i++)
            {
                cout << a[i] << " ";
            }
            cout << endl;
        }
        else
        {
            int rem = t;
            //cout<<"rem is initial "<<rem<<endl;
            while (a[k - 1] != (a[k - 2] * 2))
            {
                for (i = k - 1; i > 0; i--)
                {
                    int d = 2 * a[i - 1] - a[i];
                    rem -= d;
                    if (rem <= 0)
                    {
                        //cout<<"rem in is "<<rem;
                        flag = -1;
                        a[i] = a[i] + rem + d;
                        break;
                    }
                    else
                    {
                        a[i] = a[i - 1] * 2;
                    }
                    //cout<<"the changed is "<<i<<" the value is "<<a[i]<<endl;
                    //cout<<"rem is "<<rem<<endl;
                }
                if(flag==-1){
                    break;
                }
            }
            if (flag == -1)
            {
                cout << "YES" << endl;
                for (i = 0; i < k; i++)
                {
                    cout << a[i] << " ";
                }
                cout << endl;
            }
            else
            {
                cout << "NO" << endl;
            }
        }
    }
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    long long int n, k;
    cin >> n >> k;
    long long int i;
    long long int m = (k * (k + 1)) / 2;
    int flag = 0;
    long long int a[k];
    for (i = 0; i < k; i++)
    {
        a[i] = i + 1;
    }
    if (n < m)
    {
        cout << "NO" << endl;
    }
    else
    {
        long long int t = n - m;
        //cout<<"t is .."<<t<<endl;
        long long int fl = 0;
        // while (t > 0)
        // {
        //     t -= k;
        //     fl++;
        // }
        int rt=t/k;
        t=t-rt*k;
        fl=rt;
        if (fl == 0)
        {
            fl = 0;
        }
        else
        {
            if(t!=0){
                fl--;
                t += k;
            }
        }
        //cout << "t is " << t << endl;
        //cout << "fl is " << fl << endl;
        for (i = 0; i < k; i++)
        {
            a[i] += fl;
        }
        // for (i = 0; i < k; i++)
        // {
        //     cout<<a[i]<<endl;
        // }
        if (t == 0)
        {
            cout << "YES" << endl;
            for (i = 0; i < k; i++)
            {
                cout << a[i] << " ";
            }
            cout << endl;
        }
        else
        {
            long long int rem = t;
            //cout<<"rem is initial "<<rem<<endl;

            while (a[k - 1] != (a[k - 2] * 2))
            {
                for (i = k - 1; i > 0; i--)
                {
                    long long int d = 2 * a[i - 1] - a[i];
                    rem -= d;
                    if (rem <= 0)
                    {
                        //cout<<"rem in is "<<rem;
                        flag = -1;
                        a[i] = a[i] + rem + d;
                        break;
                    }
                    else
                    {
                        a[i] = a[i - 1] * 2;
                    }
                    //cout<<"the changed is "<<i<<" the value is "<<a[i]<<endl;
                    //cout<<"rem is "<<rem<<endl;
                }
                if(flag==-1){
                    break;
                }
            }
            if (flag == -1)
            {
                cout << "YES" << endl;
                for (i = 0; i < k; i++)
                {
                    cout << a[i] << " ";
                }
                cout << endl;
            }
            else
            {
                cout << "NO" << endl;
            }
        }
    }
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n, k;
    cin >> n >> k;
    int i;
    int m = (k * (k + 1)) / 2;
    int flag = 0;
    int a[k];
    for (i = 0; i < k; i++)
    {
        a[i] = i + 1;
    }
    if (n < m)
    {
        cout << "NO" << endl;
    }
    else
    {
        int t = n - m;
        //cout<<"t is .."<<t<<endl;
        int fl = 0;
        while (t > 0)
        {
            t -= k;
            fl++;
        }
        if (fl == 0)
        {
            fl = 0;
        }
        else
        {
            if(t!=0){
                fl--;
                t += k;
            }

        }
        cout << "t is " << t << endl;
        cout << "fl is " << fl << endl;
        for (i = 0; i < k; i++)
        {
            a[i] += fl;
        }
        // for (i = 0; i < k; i++)
        // {
        //     cout<<a[i]<<endl;
        // }
        if (t == 0)
        {
            cout << "YES" << endl;
            for (i = 0; i < k; i++)
            {
                cout << a[i] << " ";
            }
            cout << endl;
        }
        else
        {
            int rem = t;
            //cout<<"rem is initial "<<rem<<endl;
            while (a[k - 1] != (a[k - 2] * 2))
            {
                for (i = k - 1; i > 0; i--)
                {
                    int d = 2 * a[i - 1] - a[i];
                    rem -= d;
                    if (rem <= 0)
                    {
                        flag = -1;
                        a[i] = a[i] + rem + d;
                        break;
                    }
                    else
                    {
                        a[i] = a[i - 1] * 2;
                    }
                    //cout<<"rem is "<<rem<<endl;
                }
            }
            if (flag == -1)
            {
                cout << "YES" << endl;
                for (i = 0; i < k; i++)
                {
                    cout << a[i] << " ";
                }
                cout << endl;
            }
            else
            {
                cout << "NO" << endl;
            }
        }
    }
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    long long int n, k;
    cin >> n >> k;
    long long int p = k, q = k;
    //int arr[n];
    long long int sum = (p * (p + 1)) / 2, cnt = 0;
    long long int diff = n - sum;
    long long int start = diff / k + 1, check;
    check = (start) * (pow(2, k) - 1);
    if (n > check || sum>n)
    {
        cout << "NO";
    }
    else if(n==check){
        cout<<"YES"<<endl;
        cout<<start<<" ";
        for(long long int i = 1;i<k;i++){
            cout<<start*2<<" ";
        }
    }
    else
    {
        long long int arr[k], j = 0, s = 0,flag=0;
        for (long long int i = start; i < start + k; i++)
        {
            arr[j] = i;
            s += arr[j];
            j++;
        }
       long long int d = n-s;
        while(1){
            for(long long int i = k-1;i>0;i--){
                d-=(arr[i-1]*2 - arr[i]);
                if(d<=0){
                    flag++;
                    arr[i]+=d+(arr[i-1]*2 - arr[i]);
                    break;
                }
                arr[i] = arr[i-1]*2;
            }
            if(flag!=0){
                break;
            }
        }
        cout<<"YES"<<endl;
        for(long long int i = 0;i<k;i++) cout<<arr[i]<<" ";
    }
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n, k;
    cin >> n >> k;
    int i;
    int m = (k * (k + 1)) / 2;
    int flag = 0;
    int a[k];
    for(i=0;i<k;i++){
        a[i]=i+1;
    }
    if (n < m)
    {
        cout << "NO"<<endl;
    }
    else
    {
        int t = n - m;
        //cout<<"t is .."<<t<<endl;
        int fl = 0;
        while (t > 0)
        {
            t -= m;
            fl++;
        }
        if(fl==0){
            fl=0;
        }
        else{
            fl--;
            t += m;
        }
        //cout << "t is " << t << endl;
        //cout << "fl is " << fl << endl;
        for (i = 0; i < k; i++)
        {
            a[i] += fl;
        }
        // for (i = 0; i < k; i++)
        // {
        //     cout<<a[i]<<endl;
        // }
        if (t == 0)
        {
            cout << "YES" << endl;
            for (i = 0; i < k; i++)
            {
                cout << a[i] << " ";
            }
            cout << endl;
        }
        else
        {
            int rem = t;
            //cout<<"rem is initial "<<rem<<endl;
            for (i = k-1; i>0; i--)
            {
                int d = 2 * a[i-1] - a[i];
                rem -= d;
                if (rem <= 0)
                {
                    flag = -1;
                    a[i]=a[i]+rem+d;
                    break;
                }
                else{
                    a[i] = a[i-1] * 2;
                }
                //cout<<"rem is "<<rem<<endl;
            }
            if (flag == -1)
            {
                cout << "YES" << endl;
                for (i = 0; i < k; i++)
                {
                    cout << a[i] << " ";
                }
                cout<<endl;
            }
            else
            {
                cout <<"NO"<<endl;
            }
        }
    }
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    long long int n, k;
    cin >> n >> k;
    long long int i;
    long long int m = (k * (k + 1)) / 2;
    int flag = 0;
    long long int a[k];
    for (i = 0; i < k; i++)
    {
        a[i] = i + 1;
    }
    if (n < m)
    {
        cout << "NO" << endl;
    }
    else
    {
        long long int t = n - m;
        //cout<<"t is .."<<t<<endl;
        long long int fl = 0;
        // while (t > 0)
        // {
        //     t -= k;
        //     fl++;
        // }
        int rt=t/k;
        t=t-rt*k;
        fl=rt;
        // if (fl == 0)
        // {
        //     fl = 0;
        // }
        // else
        // {
        //     if(t!=0){
        //         //fl--;
        //         //t += k;
        //     }
        // }
        //cout << "t is " << t << endl;
        //cout << "fl is " << fl << endl;
        for (i = 0; i < k; i++)
        {
            a[i] += fl;
        }
        // for (i = 0; i < k; i++)
        // {
        //     cout<<a[i]<<endl;
        // }
        if (t == 0)
        {
            cout << "YES" << endl;
            for (i = 0; i < k; i++)
            {
                cout << a[i] << " ";
            }
            cout << endl;
        }
        else
        {
            long long int rem = t;
            //cout<<"rem is initial "<<rem<<endl;

            while (a[k - 1] != (a[k - 2] * 2))
            {
                for (i = k - 1; i > 0; i--)
                {
                    long long int d = 2 * a[i - 1] - a[i];
                    rem -= d;
                    if (rem <= 0)
                    {
                        //cout<<"rem in is "<<rem;
                        flag = -1;
                        a[i] = a[i] + rem + d;
                        break;
                    }
                    else
                    {
                        a[i] = a[i - 1] * 2;
                    }
                    //cout<<"the changed is "<<i<<" the value is "<<a[i]<<endl;
                    //cout<<"rem is "<<rem<<endl;
                }
                if(flag==-1){
                    break;
                }
            }
            if (flag == -1)
            {
                cout << "YES" << endl;
                for (i = 0; i < k; i++)
                {
                    cout << a[i] << " ";
                }
                cout << endl;
            }
            else
            {
                cout << "NO" << endl;
            }
        }
    }
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    long long int n, k;
    cin >> n >> k;
    long long int i;
    long long int m = (k * (k + 1)) / 2;
    int flag = 0;
    long long int a[k];
    for (i = 0; i < k; i++)
    {
        a[i] = i + 1;
    }
    if (n < m)
    {
        cout << "NO" << endl;
    }
    else
    {
        long long int t = n - m;
        //cout<<"t is .."<<t<<endl;
        long long int fl = 0;
        while (t > 0)
        {
            t -= k;
            fl++;
        }
        if (fl == 0)
        {
            fl = 0;
        }
        else
        {
            if(t!=0){
                fl--;
                t += k;
            }
        }
        //cout << "t is " << t << endl;
        //cout << "fl is " << fl << endl;
        for (i = 0; i < k; i++)
        {
            a[i] += fl;
        }
        // for (i = 0; i < k; i++)
        // {
        //     cout<<a[i]<<endl;
        // }
        if (t == 0)
        {
            cout << "YES" << endl;
            for (i = 0; i < k; i++)
            {
                cout << a[i] << " ";
            }
            cout << endl;
        }
        else
        {
            long long int rem = t;
            //cout<<"rem is initial "<<rem<<endl;
            while (a[k - 1] != (a[k - 2] * 2))
            {
                for (i = k - 1; i > 0; i--)
                {
                    long long int d = 2 * a[i - 1] - a[i];
                    rem -= d;
                    if (rem <= 0)
                    {
                        //cout<<"rem in is "<<rem;
                        flag = -1;
                        a[i] = a[i] + rem + d;
                        break;
                    }
                    else
                    {
                        a[i] = a[i - 1] * 2;
                    }
                    //cout<<"the changed is "<<i<<" the value is "<<a[i]<<endl;
                    //cout<<"rem is "<<rem<<endl;
                }
                if(flag==-1){
                    break;
                }
            }
            if (flag == -1)
            {
                cout << "YES" << endl;
                for (i = 0; i < k; i++)
                {
                    cout << a[i] << " ";
                }
                cout << endl;
            }
            else
            {
                cout << "NO" << endl;
            }
        }
    }
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    long long int n, k,l=0;
    cin >> n >> k;
    long long int p = k, q = k;
    //int arr[n];
    long long int sum = (p * (p + 1)) / 2, cnt = 0;
    long long int diff = n - sum;
    long long int start = diff / k + 1, check=0 ,m=start;
    check+=start;
    //check = (start) * (pow(2, k) - 1);
    while(l+1<k){
        check+=m*2;
        m++;
        if(check>=n){
            break;
        }
        l++;
    }
    if (n > check || sum>n)
    {
        cout << "NO";
    }
    else if(n==check){
        cout<<"YES"<<endl;
        cout<<start<<" ";
        for(long long int i = 1;i<k;i++){
            cout<<start*2<<" ";
        }
    }
    else
    {
        long long int arr[k], j = 0, s = 0,flag=0;
        for (long long int i = start; i < start + k; i++)
        {
            arr[j] = i;
            s += arr[j];
            j++;
        }
       long long int d = n-s;
        while(1){
            for(long long int i = k-1;i>0;i--){
                d-=(arr[i-1]*2 - arr[i]);
                if(d<=0){
                    flag++;
                    arr[i]+=d+(arr[i-1]*2 - arr[i]);
                    break;
                }
                arr[i] = arr[i-1]*2;
            }
            if(flag!=0){
                break;
            }
        }
        cout<<"YES"<<endl;
        for(long long int i = 0;i<k;i++) cout<<arr[i]<<" ";
    }
}


#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;;
const int N = 1e5 + 5;
int ans[N];
int main() {
	int n, k;
	cin >> n >> k;
	int al = n;
	int i = 1;
	bool flag = 1;
	double minN = n / (pow(2, k) - 1), maxN = (2 * n / k + 1 - k) / 2;
	if ((int)maxN >= minN) ans[0] = (int)maxN;
	else flag = 0;
	k--;
	n -= ans[0];
	int p = pow(2, min(k, 30));
	int sum = 0;
	if (k) sum += ans[0];
	while (flag && k) {
		minN = k<=30?(double)n / (p - 1):0, maxN = (2.0 * (n / (double)k) + 1 - k) / 2.0;
		if(k<=30) p /= 2;
		k--;
		minN = max(ans[i - 1] + 1, (int)(minN +  1 - 1e-6));
		n -= minN;
		if (maxN >= minN && minN <= 2 * ans[i - 1]) ans[i++] = minN;
		else flag = 0;
		if (k)sum += ans[i - 1];
	}
	if(i!= 1)ans[i - 1] = al - sum;
	if (flag) {
		cout << "YES" << endl;
		for (int j = 0; j < i; j++) {
			cout << ans[j] << ' ';
		}
	}
	else cout << "NO" << endl;
	return 0;
}


#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;;
const int N = 1e5 + 5;
int ans[N];
int main() {
	int n, k;
	cin >> n >> k;
	int al = n;
	int i = 1;
	bool flag = 1;
	double minN = n / (pow(2, k) - 1), maxN = (2 * n / k + 1 - k) / 2;
	if ((int)maxN >= minN) ans[0] = (int)maxN;
	else flag = 0;
	k--;
	n -= ans[0];
	int p = pow(2, k);
	int sum = 0;
	if (k) sum += ans[0];
	while (flag && k) {
		minN = (double)n / (p - 1), maxN = (2.0 * n / k + 1 - k) / 2.0;
		p /= 2;
		k--;
		minN = max(ans[i - 1] + 1, (int)(minN + 1 - 1e-6));
		n -= minN;
		if (maxN >= minN && minN <= 2 * ans[i - 1]) ans[i++] = minN;
		else flag = 0;
		if (k)sum += ans[i - 1];
	}
	if(i!= 1)ans[i - 1] = al - sum;
	if (flag) {
		cout << "YES" << endl;
		for (int j = 0; j < i; j++) {
			cout << ans[j] << ' ';
		}
	}
	else cout << "NO" << endl;
	return 0;
}


#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;;
const int N = 1e5 + 5;
int ans[N];
int main() {
	int n, k;
	cin >> n >> k;
	int al = n;
	int i = 1;
	bool flag = 1;
	double minN = n / (pow(2, k) - 1), maxN = (2 * n / k + 1 - k) / 2;
	if ((int)maxN >= minN) ans[0] = (int)maxN;
	else flag = 0;
	k--;
	n -= ans[0];
	int p = pow(2, k);
	int sum = ans[0];
	while (flag && k) {
		minN = (double)n / (p - 1), maxN = (2.0 * n / k + 1 - k) / 2.0;
		p /= 2;
		k--;
		minN = max(ans[i - 1] + 1, (int)(minN + 1 - 1e-6));
		n -= minN;
		if (maxN >= minN && minN <= 2 * ans[i - 1]) ans[i++] = minN;
		else flag = 0;
		if (k)sum += ans[i - 1];
	}
	ans[i - 1] = al - sum;
	if (flag) {
		cout << "YES" << endl;
		for (int j = 0; j < i; j++) {
			cout << ans[j] << ' ';
		}
	}
	else cout << "NO" << endl;
	return 0;
}


#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;;
const int N = 1e5 + 5;
int ans[N];
int main() {
	int n, k;
	cin >> n >> k;
	int al = n;
	int i = 1;
	bool flag = 1;
	double minN = n / (pow(2, k) - 1), maxN = (2 * n / k + 1 - k) / 2;
	if ((int)maxN >= minN) ans[0] = (int)maxN;
	else flag = 0;
	k--;
	n -= ans[0];
	int p = pow(2, min(k, 31));
	int sum = 0;
	if (k) sum += ans[0];
	while (flag && k) {
		minN = k<=31?(double)n / (p - 1):0, maxN = (2.0 * n / k + 1 - k) / 2.0;
		if(k<=31) p /= 2;
		k--;
		minN = max(ans[i - 1] + 1, (int)(minN +  1 - 1e-6));
		n -= minN;
		if (maxN >= minN && minN <= 2 * ans[i - 1]) ans[i++] = minN;
		else flag = 0;
		if (k)sum += ans[i - 1];
	}
	if(i!= 1)ans[i - 1] = al - sum;
	if (flag) {
		cout << "YES" << endl;
		for (int j = 0; j < i; j++) {
			cout << ans[j] << ' ';
		}
	}
	else cout << "NO" << endl;
	return 0;
}


#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<stack>
#include<queue>
using namespace std;;
const int N = 1e5 + 5;
int ans[N];
int main() {
	int n, k;
	cin >> n >> k;
	int i = 1;
	bool flag = 1;
	double minN = n / (pow(2, k) - 1), maxN = (2 * n / k + 1 - k) / 2;
	if ((int)maxN >= minN) ans[0] = (int)maxN;
	else flag = 0;
	k--;
	n -= ans[0];
	int p = pow(2, k);
	while (flag && k) {
		minN = (double)n / (p - 1), maxN = (2.0 * n / k + 1 - k) / 2.0;
		p /= 2;
		k--;
		minN = max(ans[i - 1] + 1, (int)(minN + 1 - 1e-6));
		n -= minN;
		if (maxN >= minN && minN <= 2 * ans[i - 1]) ans[i++] = minN;
		else flag = 0;
	}
	if (flag) {
		cout << "YES" << endl;
		for (int j = 0; j < i; j++) {
			cout << ans[j] << ' ';
		}
	}
	else cout << "NO" << endl;
	return 0;
}


#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;;
const int N = 1e5 + 5;
int ans[N];
int main() {
	int n, k;
	cin >> n >> k;
	int al = n;
	int i = 1;
	bool flag = 1;
	double minN = n / (pow(2, k) - 1), maxN = (2 * n / k + 1 - k) / 2;
	if ((int)maxN >= minN) ans[0] = (int)maxN;
	else flag = 0;
	k--;
	n -= ans[0];
	int p = pow(2, min(k, 31));
	int sum = 0;
	if (k) sum += ans[0];
	while (flag && k) {
		minN = k<=31?(double)n / (p - 1):0, maxN = (2.0 * (n / (double)k) + 1 - k) / 2.0;
		if(k<=31) p /= 2;
		k--;
		minN = max(ans[i - 1] + 1, (int)(minN +  1 - 1e-6));
		n -= minN;
		if (maxN >= minN && minN <= 2 * ans[i - 1]) ans[i++] = minN;
		else flag = 0;
		if (k)sum += ans[i - 1];
	}
	if(i!= 1)ans[i - 1] = al - sum;
	if (flag) {
		cout << "YES" << endl;
		for (int j = 0; j < i; j++) {
			cout << ans[j] << ' ';
		}
	}
	else cout << "NO" << endl;
	return 0;
}


#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;;
const int N = 1e5 + 5;
int ans[N];
int main() {
	int n, k;
	cin >> n >> k;
	int i = 1;
	bool flag = 1;
	double minN = n / (pow(2, k) - 1), maxN = (2 * n / k + 1 - k) / 2;
	if ((int)maxN >= minN) ans[0] = (int)maxN;
	else flag = 0;
	k--;
	n -= ans[0];
	int p = pow(2, k);
	while (flag && k) {
		minN = (double)n / (p - 1), maxN = (2.0 * n / k + 1 - k) / 2.0;
		p /= 2;
		k--;
		minN = max(ans[i - 1] + 1, (int)(minN + 1 - 1e-6));
		n -= minN;
		if (maxN >= minN && minN <= 2 * ans[i - 1]) ans[i++] = minN;
		else flag = 0;
	}
	if (flag) {
		cout << "YES" << endl;
		for (int j = 0; j < i; j++) {
			cout << ans[j] << ' ';
		}
	}
	else cout << "NO" << endl;
	return 0;
}


#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;;
const int N = 1e5 + 5;
int ans[N];
int main() {
	int n, k;
	cin >> n >> k;
	int al = n;
	int i = 1;
	bool flag = 1;
	double minN = n / (pow(2, k) - 1), maxN = (2 * n / k + 1 - k) / 2;
	if ((int)maxN >= minN) ans[0] = (int)maxN;
	else flag = 0;
	k--;
	n -= ans[0];
	int p = pow(2, k);
	int sum;
	if (k) sum += ans[0];
	while (flag && k) {
		minN = (double)n / (p - 1), maxN = (2.0 * n / k + 1 - k) / 2.0;
		p /= 2;
		k--;
		minN = max(ans[i - 1] + 1, (int)(minN + 1 - 1e-6));
		n -= minN;
		if (maxN >= minN && minN <= 2 * ans[i - 1]) ans[i++] = minN;
		else flag = 0;
		if (k)sum += ans[i - 1];
	}
	ans[i - 1] = al - sum;
	if (flag) {
		cout << "YES" << endl;
		for (int j = 0; j < i; j++) {
			cout << ans[j] << ' ';
		}
	}
	else cout << "NO" << endl;
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
/// Typedef
typedef long long           ll;
typedef vector<int>         vi;
typedef pair<int,int>       pii;

#define pb                  push_back
#define ppb                 pop_back
#define MP                  make_pair
#define ff                  first
#define ss                  second
#define sf                  scanf
#define pf                  printf
#define SQR(x)              ((x)*(x))
#define loop(i, y)          for(int i=0; i<int(y); i++)
#define FOR(i, x, y)        for(int i=int(x); i<int(y); i++)
#define ROF(i, x, y)        for(int i=int(x); i>=int(y); i--)
#define all(c)              c.begin(), c.end()
#define sz(c)               int(c.size())
#define clr(x, y)           memset(x, y, sizeof(x))
#define si(x)               scanf("%d", &x)
#define sii(x, y)           scanf("%d %d", &x, &y)
#define siii(x, y, z)       scanf("%d %d %d", &x, &y, &z)
#define sl(x)               scanf("%lld", &x)
#define sll(x, y)           scanf("%lld %lld", &x, &y)
#define slll(x, y, z)       scanf("%lld %lld %lld", &x, &y, &z)

#ifdef VAMP
     #define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template < typename Arg1 >
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " = " << arg1 << std::endl;
    }
    template < typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names+1, ',');
        cerr.write(names, comma - names) << " = " << arg1 <<" | ";
        __f(comma+1, args...);
    }
#else
    #define debug(...)
#endif
///******************************************START******************************************

/// Constants
#define MAX                 200005
#define MOD                 1000000007
#define eps                 1e-9
#define INF              	0x3f3f3f3f3f3f3f3f // 4,557,430,888,798,830,399
#define inf                 0x3f3f3f3f // 1,061,109,567
#define PI                  acos(-1.0)  // 3.1415926535897932

vector<ll> v;

int main(){
    #ifdef VAMP
        clock_t tStart = clock();
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
   	ll n, k; sll(n, k);
   	ll last=0, sum=0;
   	for(int i=1; i<=k; i++){
   		ll lo=last+1, ans=lo;
   		ll hi= last?last*2:n;
   		while(lo<=hi){
   			ll mid=(lo+hi)>>1;
   			ll lm=mid, hm=lm+(k-i);
   			if((lm+hm)*(k-i+1)/2 > n) hi=mid-1;
   			else ans=lo, lo=mid+1;
   		}
   		lo=ans;
   		hi=lo+(k-i);
   		ll tot=(hi+lo)*(k-i+1)/2;
   		if(tot>n) printf("NO\n"), exit(0);
   		v.pb(lo);
   		n-=lo;
   		last=lo;
   		sum+=last;
   	}
   	if(n) printf("NO\n"), exit(0);
   	printf("YES\n");
   	for(auto &x: v){
   		printf("%lld ", x);
   	}

    #ifdef VAMP
        fprintf(stderr, "\n>> Runtime: %.10fs\n", (double) (clock() - tStart) / CLOCKS_PER_SEC);
    #endif
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
/// Typedef
typedef long long           ll;
typedef vector<int>         vi;
typedef pair<int,int>       pii;

#define pb                  push_back
#define ppb                 pop_back
#define MP                  make_pair
#define ff                  first
#define ss                  second
#define sf                  scanf
#define pf                  printf
#define SQR(x)              ((x)*(x))
#define loop(i, y)          for(int i=0; i<int(y); i++)
#define FOR(i, x, y)        for(int i=int(x); i<int(y); i++)
#define ROF(i, x, y)        for(int i=int(x); i>=int(y); i--)
#define all(c)              c.begin(), c.end()
#define sz(c)               int(c.size())
#define clr(x, y)           memset(x, y, sizeof(x))
#define si(x)               scanf("%d", &x)
#define sii(x, y)           scanf("%d %d", &x, &y)
#define siii(x, y, z)       scanf("%d %d %d", &x, &y, &z)
#define sl(x)               scanf("%lld", &x)
#define sll(x, y)           scanf("%lld %lld", &x, &y)
#define slll(x, y, z)       scanf("%lld %lld %lld", &x, &y, &z)

#ifdef VAMP
     #define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template < typename Arg1 >
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " = " << arg1 << std::endl;
    }
    template < typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names+1, ',');
        cerr.write(names, comma - names) << " = " << arg1 <<" | ";
        __f(comma+1, args...);
    }
#else
    #define debug(...)
#endif
///******************************************START******************************************

/// Constants
#define MAX                 200005
#define MOD                 1000000007
#define eps                 1e-9
#define INF              	0x3f3f3f3f3f3f3f3f // 4,557,430,888,798,830,399
#define inf                 0x3f3f3f3f // 1,061,109,567
#define PI                  acos(-1.0)  // 3.1415926535897932

vector<ll> v;

int main(){
    #ifdef VAMP
        clock_t tStart = clock();
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
   	ll n, k; sll(n, k);
   	ll last=0, sum=0;
   	for(int i=1; i<k; i++){
   		ll lo=last+1, ans=lo;
   		ll hi=last*2;
   		while(lo<=hi){
   			ll mid=(lo+hi)>>1;
   			ll lm=mid, hm=lm+(k-i);
   			if((lm+hm)*(k-i+1)/2 > n) hi=mid-1;
   			else ans=lo, lo=mid+1;
   		}
   		lo=ans;
   		hi=lo+(k-i);
   		ll tot=(hi+lo)*(k-i+1)/2;
   		if(tot>n) printf("NO\n"), exit(0);
   		v.pb(lo);
   		n-=lo;
   		last=lo;
   		sum+=last;
   	}
   	// printf("%lld %lld\n", n, last);
   	if((last and n>last*2) or n<=last) printf("NO\n"), exit(0);
   	v.pb(n);
   	printf("YES\n");
   	for(auto &x: v){
   		printf("%lld ", x);
   	}

    #ifdef VAMP
        fprintf(stderr, "\n>> Runtime: %.10fs\n", (double) (clock() - tStart) / CLOCKS_PER_SEC);
    #endif
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
/// Typedef
typedef long long           ll;
typedef vector<int>         vi;
typedef pair<int,int>       pii;

#define pb                  push_back
#define ppb                 pop_back
#define MP                  make_pair
#define ff                  first
#define ss                  second
#define sf                  scanf
#define pf                  printf
#define SQR(x)              ((x)*(x))
#define loop(i, y)          for(int i=0; i<int(y); i++)
#define FOR(i, x, y)        for(int i=int(x); i<int(y); i++)
#define ROF(i, x, y)        for(int i=int(x); i>=int(y); i--)
#define all(c)              c.begin(), c.end()
#define sz(c)               int(c.size())
#define clr(x, y)           memset(x, y, sizeof(x))
#define si(x)               scanf("%d", &x)
#define sii(x, y)           scanf("%d %d", &x, &y)
#define siii(x, y, z)       scanf("%d %d %d", &x, &y, &z)
#define sl(x)               scanf("%lld", &x)
#define sll(x, y)           scanf("%lld %lld", &x, &y)
#define slll(x, y, z)       scanf("%lld %lld %lld", &x, &y, &z)

#ifdef VAMP
     #define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template < typename Arg1 >
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " = " << arg1 << std::endl;
    }
    template < typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names+1, ',');
        cerr.write(names, comma - names) << " = " << arg1 <<" | ";
        __f(comma+1, args...);
    }
#else
    #define debug(...)
#endif
///******************************************START******************************************

/// Constants
#define MAX                 200005
#define MOD                 1000000007
#define eps                 1e-9
#define INF              	0x3f3f3f3f3f3f3f3f // 4,557,430,888,798,830,399
#define inf                 0x3f3f3f3f // 1,061,109,567
#define PI                  acos(-1.0)  // 3.1415926535897932

vector<ll> v;

int main(){
    #ifdef VAMP
        clock_t tStart = clock();
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
   	ll n, k; sll(n, k);
   	ll last=0, sum=0;
   	for(int i=1; i<k; i++){
   		ll lo=last+1, ans=lo;
   		ll hi= last?last*2:n;
   		while(lo<=hi){
   			ll mid=(lo+hi)>>1;
   			ll lm=mid, hm=lm+(k-i);
   			if((lm+hm)*(k-i+1)/2 > n) hi=mid-1;
   			else ans=lo, lo=mid+1;
   		}
   		lo=ans;
   		hi=lo+(k-i);
   		ll tot=(hi+lo)*(k-i+1)/2;
   		if(tot>n) printf("NO\n"), exit(0);
   		v.pb(lo);
   		n-=lo;
   		last=lo;
   		sum+=last;
   	}
   	if(!last) printf("1\n%lld\n", n), exit(0);
   	if(n<=last or n>last*2) printf("NO\n"), exit(0);
   	v.pb(n);
   	printf("YES\n");
   	for(auto &x: v){
   		printf("%lld ", x);
   	}

    #ifdef VAMP
        fprintf(stderr, "\n>> Runtime: %.10fs\n", (double) (clock() - tStart) / CLOCKS_PER_SEC);
    #endif
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
/// Typedef
typedef long long           ll;
typedef vector<int>         vi;
typedef pair<int,int>       pii;

#define pb                  push_back
#define ppb                 pop_back
#define MP                  make_pair
#define ff                  first
#define ss                  second
#define sf                  scanf
#define pf                  printf
#define SQR(x)              ((x)*(x))
#define loop(i, y)          for(int i=0; i<int(y); i++)
#define FOR(i, x, y)        for(int i=int(x); i<int(y); i++)
#define ROF(i, x, y)        for(int i=int(x); i>=int(y); i--)
#define all(c)              c.begin(), c.end()
#define sz(c)               int(c.size())
#define clr(x, y)           memset(x, y, sizeof(x))
#define si(x)               scanf("%d", &x)
#define sii(x, y)           scanf("%d %d", &x, &y)
#define siii(x, y, z)       scanf("%d %d %d", &x, &y, &z)
#define sl(x)               scanf("%lld", &x)
#define sll(x, y)           scanf("%lld %lld", &x, &y)
#define slll(x, y, z)       scanf("%lld %lld %lld", &x, &y, &z)

#ifdef VAMP
     #define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template < typename Arg1 >
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " = " << arg1 << std::endl;
    }
    template < typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names+1, ',');
        cerr.write(names, comma - names) << " = " << arg1 <<" | ";
        __f(comma+1, args...);
    }
#else
    #define debug(...)
#endif
///******************************************START******************************************

/// Constants
#define MAX                 200005
#define MOD                 1000000007
#define eps                 1e-9
#define INF              	0x3f3f3f3f3f3f3f3f // 4,557,430,888,798,830,399
#define inf                 0x3f3f3f3f // 1,061,109,567
#define PI                  acos(-1.0)  // 3.1415926535897932

vector<ll> v;

int main(){
    #ifdef VAMP
        clock_t tStart = clock();
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
   	ll n, k; sll(n, k);
   	ll last=0, sum=0;
   	for(int i=1; i<=k; i++){
   		ll lo=last+1, ans=lo;
   		ll hi= last?last*2:n;
   		while(lo<=hi){
   			ll mid=(lo+hi)>>1;
   			ll lm=mid, hm=lm+(k-i);
   			ll now=(lm+hm)*(k-i+1)/2;
   			if(now > n) hi=mid-1;
   			else ans=mid, lo=mid+1;
   		}
   		lo=ans;
   		hi=lo+(k-i);
   		ll tot=(hi+lo)*(k-i+1)/2;
   		if(tot>n) printf("NO\n"), exit(0);
   		v.pb(lo);
   		n-=lo;
   		last=lo;
   		sum+=last;
   	}
   	printf("YES\n");
   	for(auto &x: v){
   		printf("%lld ", x);
   	}

    #ifdef VAMP
        fprintf(stderr, "\n>> Runtime: %.10fs\n", (double) (clock() - tStart) / CLOCKS_PER_SEC);
    #endif
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
/// Typedef
typedef long long           ll;
typedef vector<int>         vi;
typedef pair<int,int>       pii;

#define pb                  push_back
#define ppb                 pop_back
#define MP                  make_pair
#define ff                  first
#define ss                  second
#define sf                  scanf
#define pf                  printf
#define SQR(x)              ((x)*(x))
#define loop(i, y)          for(int i=0; i<int(y); i++)
#define FOR(i, x, y)        for(int i=int(x); i<int(y); i++)
#define ROF(i, x, y)        for(int i=int(x); i>=int(y); i--)
#define all(c)              c.begin(), c.end()
#define sz(c)               int(c.size())
#define clr(x, y)           memset(x, y, sizeof(x))
#define si(x)               scanf("%d", &x)
#define sii(x, y)           scanf("%d %d", &x, &y)
#define siii(x, y, z)       scanf("%d %d %d", &x, &y, &z)
#define sl(x)               scanf("%lld", &x)
#define sll(x, y)           scanf("%lld %lld", &x, &y)
#define slll(x, y, z)       scanf("%lld %lld %lld", &x, &y, &z)

#ifdef VAMP
     #define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template < typename Arg1 >
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " = " << arg1 << std::endl;
    }
    template < typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names+1, ',');
        cerr.write(names, comma - names) << " = " << arg1 <<" | ";
        __f(comma+1, args...);
    }
#else
    #define debug(...)
#endif
///******************************************START******************************************

/// Constants
#define MAX                 200005
#define MOD                 1000000007
#define eps                 1e-9
#define INF              	0x3f3f3f3f3f3f3f3f // 4,557,430,888,798,830,399
#define inf                 0x3f3f3f3f // 1,061,109,567
#define PI                  acos(-1.0)  // 3.1415926535897932

vector<ll> v;

int main(){
    #ifdef VAMP
        clock_t tStart = clock();
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
   	ll n, k; sll(n, k);
   	ll last=0, sum=0;
   	for(int i=1; i<k; i++){
   		ll lo=last+1, ans=lo;
   		ll hi= last?last*2:n;
   		while(lo<=hi){
   			ll mid=(lo+hi)>>1;
   			ll lm=mid, hm=lm+(k-i);
   			if((lm+hm)*(k-i+1)/2 > n) hi=mid-1;
   			else ans=lo, lo=mid+1;
   		}
   		lo=ans;
   		hi=lo+(k-i);
   		ll tot=(hi+lo)*(k-i+1)/2;
   		if(tot>n) printf("NO\n"), exit(0);
   		v.pb(lo);
   		n-=lo;
   		last=lo;
   		sum+=last;
   	}
   	if(!last) printf("YES\n%lld\n", n), exit(0);
   	if(n<=last or n>last*2) printf("NO\n"), exit(0);
   	v.pb(n);
   	printf("YES\n");
   	for(auto &x: v){
   		printf("%lld ", x);
   	}

    #ifdef VAMP
        fprintf(stderr, "\n>> Runtime: %.10fs\n", (double) (clock() - tStart) / CLOCKS_PER_SEC);
    #endif
    return 0;
}