#include <iostream>
#include <deque>
#include <vector>

using namespace std;


struct assignment
{
  int carriage;
  int track;
};



int main(void)
{

  int carriageCount, trackCount;


  while (   (cin >> carriageCount >> trackCount)
         && ((carriageCount != 0) || (trackCount != 0)))
  {
     // prirazeni vagonu tratim
     assignment* assignments = new assignment[carriageCount];

     // poradi, v jakem odjizdeji
     int* outOrder = new int[carriageCount];

     // nacteni vstupniho poradi
     for (int i=0; i<carriageCount; i++)
     {
        cin >> assignments[i].carriage;
        assignments[i].track = -1;
     }

     bool wasError = false;
     int assignedCarriagesCount = 0;
     for (int trackBeingAssigned = 1; assignedCarriagesCount < carriageCount; 
          trackBeingAssigned++)
     {
       if (trackBeingAssigned > trackCount)
       {
         wasError = true;
         break;
       }


       int carriageValue = -1;
       for (int currentCarriage = 0; currentCarriage < carriageCount; currentCarriage++)
       {
         if (assignments[currentCarriage].track == -1)
         {
           if (assignments[currentCarriage].carriage > carriageValue)
           {
              carriageValue = assignments[currentCarriage].carriage;
              assignments[currentCarriage].track = trackBeingAssigned;
              outOrder[carriageValue-1] = trackBeingAssigned;
              assignedCarriagesCount++;
           }
         }
       }
     }

     if (wasError) { cout << "Transportation failed" << endl; }
     else
     {
        for (int i = 0; i < carriageCount; i++)
	{ 
           cout << assignments[i].track;
           if (i != carriageCount-1) cout << " "; 
	}
        cout << endl;
        for (int i = 0; i < carriageCount; i++)
	{ 
           cout << outOrder[i];
           if (i != carriageCount-1) cout << " "; 
	}
        cout << endl;
     }
   }

/*




     int currentTrack = 1;
     int carriageValue = assignments[0].carriage;

     for (int i=0; i<carriageCount; i++)
     {
        if (assignments[i].carriage > carriageValue)
        {
          carriageValue = assignments[i].carriage;
          assignments[i].track = currentTrack;
        }
     }



 
     vector<deque<int> > tracks;

     for (int i=0; i<trackCount; i++)
     {
       tracks.push_back(deque<int>());
     }



     bool wasError = false;
     while (!inOrder.empty())
     {
       int lowestDiff = carriageCount * 2;
       int lowestDiffTrackIndex = -1;



       for (int i=0; i<trackCount; i++)
       {
         if (tracks[i].empty())
         {
           lowestDiff = carriageCount * 2 - 1;
           lowestDiffTrackIndex = i;
         }
         else
         {
           int diff = inOrder.front() - tracks[i].back();

           if ((diff > 0) && (diff < lowestDiff))
           {
             lowestDiff = diff;
             lowestDiffTrackIndex = i;
           }
         }
       }





       if (lowestDiffTrackIndex == -1)
       {
          wasError = true;
          break;
       }
       else
       {
          //assigning to a track
          outOrder[inOrder.front() - 1] = (trackCount - lowestDiffTrackIndex);

          tracks[lowestDiffTrackIndex].push_back(inOrder.front());
          trackAssign.push_back(lowestDiffTrackIndex);
          inOrder.pop_front();
       }

     }


    if (wasError)
    {
      cout << "Transportation failed" << endl;
    }
    else
    {
      while (!trackAssign.empty())
      {
        cout << (trackCount - trackAssign.front());
        trackAssign.pop_front();
        if (!trackAssign.empty())
        {
           cout << " ";
        }
      }
      cout << endl;

      for (int i=0; i<carriageCount; i++)
      {
        cout << outOrder[i];
        if (i != carriageCount-1)
        {
          cout << " ";
        }
      }
      cout << endl;

    }

    
  }
*/

  return 0;
}