//Optional FAST

//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,fma,abm,mmx,avx,avx2,tune=native")

//Required Libraries

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>

//Required namespaces

using namespace std;
using namespace __gnu_pbds;

//Required defines

#define endl '\n'

#define READ(X) cin>>X;
#define READV(X) long long X; cin>>X;
#define READAR(A,N) long long A[N]; for(long long i=0;i<N;i++) {cin>>A[i];}
#define rz(A,N) A.resize(N);
#define sz(X) (long long)(X.size())
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define FORI(a,b,c) for(long long a=b;a<c;a++)
#define FORD(a,b,c) for(long long a=b;a>c;a--)

//Required typedefs

typedef tree<long long,null_type,less<long long>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef tree<long long,null_type,greater<long long>,rb_tree_tag,tree_order_statistics_node_update> ordered_set1;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<long long,long long> pll;

//Required Constants

const long long inf=(long long)1e18;
const long long MOD=(long long)(1e9+7);
const long long INIT=(long long)(1e6+1);
const long double PI=3.14159265358979;

//Required Functions

ll power(ll x,ll y) 
{ 
    if (y == 0) 
        return 1; 
    ll p = power(x, y/2) % MOD; 
    p = (p * p) % MOD; 
  
    return (y%2 == 0)? p : (x * p) % MOD; 
}
ll modInverse(ll a) 
{ 
   return power(a,MOD-2); 
   
}

//Work

int main()
{
    #ifndef ONLINE_JUDGE
    if (fopen("INPUT.txt", "r"))
    {
        freopen ("INPUT.txt" , "r" , stdin);
        //freopen ("OUTPUT.txt" , "w" , stdout);
    }
    #endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    clock_t clk;
    clk = clock();
//-----------------------------------------------------------------------------------------------------------//

    READV(T);
    while(T--)
    {
        READV(N);
        READV(K);
        pair<pll,ll> Z[N];
        FORI(i,0,N)
        {
            READ(Z[i].fi.se);
            READ(Z[i].fi.fi);
            Z[i].se=i+1;
        }
        sort(Z,Z+N);
        ll dp[N+1][N+1];
        FORI(i,0,N+1)
        {
            FORI(j,0,N+1)
            {
                dp[i][j]=-inf;
            }
        }
        dp[0][0]=0;
        ll back_tracker[N+1][N+1];
        memset(back_tracker,0,sizeof(back_tracker));
        FORI(i,0,N)
        {
            FORI(j,0,N)
            {
                if(dp[i][j]>=0)
                {
                    if(dp[i+1][j]<dp[i][j]+j*Z[i].fi.fi)
                    {
                        dp[i+1][j]=dp[i][j]+j*Z[i].fi.fi;
                        back_tracker[i+1][j]=j;
                    }
                    if(dp[i+1][j+1]<dp[i][j]+Z[i].fi.se+j*Z[i].fi.fi)
                    {
                        dp[i+1][j+1]=dp[i][j]+Z[i].fi.se+j*Z[i].fi.fi;
                        back_tracker[i+1][j+1]=j;
                    }
                }
            }
        }
        vector<ll> ans1,ans2;
        ll current=K;
        FORD(i,N,0)
        {
            if(back_tracker[i][current]==current)
            {
                ans2.pb(Z[i-1].se);
            }
            else
            {
                ans1.pb(Z[i-1].se);
            }
            current=back_tracker[i][current];
        }
        reverse(ans1.begin(),ans1.end());
        reverse(ans2.begin(),ans2.end());
        cout<<sz(ans2)*2+sz(ans1)<<endl;
        FORI(i,0,sz(ans1)-1)
        {
            cout<<ans1[i]<<" ";
        }
        FORI(i,0,sz(ans2))
        {
            cout<<ans2[i]<<" "<<-ans2[i]<<" ";
        }
        cout<<ans1.back()<<endl;
    }

//-----------------------------------------------------------------------------------------------------------//


    clk = clock() - clk;
    cerr << fixed << setprecision(6) << "Time: " << ((double)clk)/CLOCKS_PER_SEC << endl;

    return 0;
}