#include<bits/stdc++.h>

#define LL long long

#define fi first

#define se second

#define mk make_pair

#define PLL pair<LL, LL>

#define PLI pair<LL, int>

#define PII pair<int, int>

#define SZ(x) ((int)x.size())

#define ull unsigned long long

using namespace std;

const int N = 3e5 + ;

const int inf = 0x3f3f3f3f;

const LL INF = 0x3f3f3f3f3f3f3f3f;

const int mod = 1e9 + ;

const double eps = 1e-;

const double PI = acos(-);

#define lson l, mid, rt->ls

#define rson mid + 1, r, rt->rs

struct Node {

    Node() {

        ls = rs = NULL;

        sum = cnt = ;

    }

    Node *ls, *rs;

    LL sum;

    int cnt;

};

inline void pull(Node* rt) {

    rt->cnt = rt->ls->cnt + rt->rs->cnt;

    rt->sum = rt->ls->sum + rt->rs->sum;

    if(!rt->ls->cnt) delete rt->ls, rt->ls = NULL;

    if(!rt->rs->cnt) delete rt->rs, rt->rs = NULL;

}

inline void push(Node* rt) {

    if(!rt->ls) rt->ls = new Node();

    if(!rt->rs) rt->rs = new Node();

}

void update(int p, int c, int l, int r, Node* rt) {

    if(l == r) {

        rt->cnt += c;

        rt->sum += 1LL * p * c;

        return;

    }

    push(rt);

    int mid = l + r >> ;

    if(p <= mid) update(p, c, lson);

    else update(p, c, rson);

    pull(rt);

}

LL query(int k, int l, int r, Node* rt) {

    if(!k) return ;

    if(rt->cnt <= k) return rt->sum;

    if(l == r) return 1LL * k * l;

    push(rt);

    int mid = l + r >> ;

    if(rt->ls->cnt >= k) return query(k, lson);

    else return query(rt->ls->cnt, lson) + query(k - rt->ls->cnt, rson);

}

int n, w, a[N], b[N], id[N], fin[N];

LL ans = INF;

bool cmpa(int x, int y) {

    return a[x] < a[y];

}

bool cmpb(int x, int y) {

    return b[x] < b[y];

}

int main() {

    Node* Rt = new Node();

    scanf("%d%d", &n, &w);

    for(int i = ; i <= n; i++) scanf("%d%d", &a[i], &b[i]);

    for(int i = ; i <= n; i++) id[i] = i;

    int where = -;

    sort(id + , id +  + n, cmpa);

    if(w <= n) {

        LL ret = ;

        for(int i = ; i <= w; i++) ret += a[id[i]];

        ans = min(ans, ret);

        where = ;

    }

    sort(id + , id +  + n, cmpb);

    for(int i = ; i <= n; i++) update(a[id[i]], , , inf, Rt);

    LL prefix = ;

    LL ret = ;

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

        int x = id[i];

        update(a[x], -, , inf, Rt);

        ret = prefix + b[x];

        int need = w - (i + );

        if(Rt->cnt >= need) {

            ret += query(need, , inf, Rt);

            if(ret < ans) {

                ans = ret;

                where = i;

            }

        }

        prefix += a[x];

        update(b[x] - a[x], , , inf, Rt);

    }

    if(!where) {

        sort(id + , id +  + n, cmpa);

        for(int i = ; i <= w; i++) fin[id[i]] = ;

    } else {

        priority_queue<PII, vector<PII>, greater<PII> > que;

        fin[id[where]] = ;

        w -= where + ;

        for(int i = ; i < where; i++) que.push(mk(b[id[i]] - a[id[i]], i)), fin[id[i]] = ;

        for(int i = where + ; i <= n; i++) que.push(mk(a[id[i]], i));

        while(w--) {

            int who = que.top().se;

            que.pop();

            if(who < where) fin[id[who]] = ;

            else fin[id[who]] = ;

        }

    }

    printf("%lld\n", ans);

    for(int i = ; i <= n; i++) printf("%d", fin[i]);

    puts("");

    return ;

}

/*

*/