if (!sub && sl)
      {                         // can encode Text
         bl = 0;
         if (p + sl < l)
            for (e = 0; e < E_MAX; e++)
               if (enc[p + sl][e].t && ((t = enc[p + sl][e].t + switchcost[E_TEXT][e]) < bl || !bl))
               {
                  bl = t;
                  b = e;
               }
         if (exact && enc[p + sl][E_ASCII].t == 1 && 1 < bl)
         {                      // special case, switch to ASCII for last bytes
            bl = 1;
            b = E_ASCII;
         }
         enc[p][E_TEXT].t = tl + bl;
         enc[p][E_TEXT].s = sl;
         if (bl && b == E_TEXT)
            enc[p][b].s += enc[p + sl][b].s;
      }
      // X12
      sub = tl = sl = 0;
      do
      {
         unsigned char c = s[p + sl++];
         if (c != 13 && c != '*' && c != '>' && c != ' ' && !isdigit (c) && !isupper (c))
         {
            sl = 0;
            break;
         }
         sub++;
         while (sub >= 3)
         {
            sub -= 3;
            tl += 2;
         }
      } while (sub && p + sl < l);
      if (!sub && sl)
      {                         // can encode X12
         bl = 0;
         if (p + sl < l)
            for (e = 0; e < E_MAX; e++)
               if (enc[p + sl][e].t && ((t = enc[p + sl][e].t + switchcost[E_X12][e]) < bl || !bl))
               {
                  bl = t;
                  b = e;
               }
         if (exact && enc[p + sl][E_ASCII].t == 1 && 1 < bl)
         {                      // special case, switch to ASCII for last bytes
            bl = 1;
            b = E_ASCII;
         }
         enc[p][E_X12].t = tl + bl;
         enc[p][E_X12].s = sl;
         if (bl && b == E_X12)
            enc[p][b].s += enc[p + sl][b].s;
      }
      // EDIFACT
      sl = bl = 0;
      if (s[p + 0] >= 32 && s[p + 0] <= 94)
      {                         // can encode 1
         char bs = 0;
         if (p + 1 == l && (!bl || bl < 2))
         {
            bl = 2;
            bs = 1;
         } else
            for (e = 0; e < E_MAX; e++)
               if (e != E_EDIFACT && enc[p + 1][e].t && ((t = 2 + enc[p + 1][e].t + switchcost[E_ASCII][e]) < bl || !bl))       // E_ASCII as allowed for unlatch
               {
                  bs = 1;
                  bl = t;
                  b = e;
               }
         if (p + 1 < l && s[p + 1] >= 32 && s[p + 1] <= 94)
         {                      // can encode 2
            if (p + 2 == l && (!bl || bl < 2))
            {
               bl = 3;
               bs = 2;
            } else
               for (e = 0; e < E_MAX; e++)
                  if (e != E_EDIFACT && enc[p + 2][e].t && ((t = 3 + enc[p + 2][e].t + switchcost[E_ASCII][e]) < bl || !bl))    // E_ASCII as allowed for unlatch
                  {
                     bs = 2;
                     bl = t;
                     b = e;
                  }
            if (p + 2 < l && s[p + 2] >= 32 && s[p + 2] <= 94)
            {                   // can encode 3
               if (p + 3 == l && (!bl || bl < 3))
               {
                  bl = 3;
                  bs = 3;
               } else
                  for (e = 0; e < E_MAX; e++)
                     if (e != E_EDIFACT && enc[p + 3][e].t && ((t = 3 + enc[p + 3][e].t + switchcost[E_ASCII][e]) < bl || !bl)) // E_ASCII as allowed for unlatch
                     {
                        bs = 3;
                        bl = t;
                        b = e;
                     }
               if (p + 4 < l && s[p + 3] >= 32 && s[p + 3] <= 94)
               {                // can encode 4
                  if (p + 4 == l && (!bl || bl < 3))
                  {
                     bl = 3;
                     bs = 4;
                  } else
                  {
                     for (e = 0; e < E_MAX; e++)
                        if (enc[p + 4][e].t && ((t = 3 + enc[p + 4][e].t + switchcost[E_EDIFACT][e]) < bl || !bl))
                        {
                           bs = 4;
                           bl = t;
                           b = e;
                        }
                     if (exact && enc[p + 4][E_ASCII].t && enc[p + 4][E_ASCII].t <= 2 && (t = 3 + enc[p + 4][E_ASCII].t) < bl)
                     {          // special case, switch to ASCII for last 1 ot two bytes
                        bs = 4;
                        bl = t;
                        b = E_ASCII;
                     }
                  }
               }
            }
         }
         enc[p][E_EDIFACT].t = bl;
         enc[p][E_EDIFACT].s = bs;
         if (bl && b == E_EDIFACT)
            enc[p][b].s += enc[p + bs][b].s;
      }
      // Binary
      bl = 0;
      for (e = 0; e < E_MAX; e++)
         if (enc[p + 1][e].t
             && ((t = enc[p + 1][e].t + switchcost[E_BINARY][e] + ((e == E_BINARY && enc[p + 1][e].t == 249) ? 1 : 0)) < bl || !bl))
         {
            bl = t;
            b = e;
         }
      enc[p][E_BINARY].t = 1 + bl;
      enc[p][E_BINARY].s = 1;
      if (bl && b == E_BINARY)
         enc[p][b].s += enc[p + 1][b].s;
      //fprintf (stderr, "%d:", p); for (e = 0; e < E_MAX; e++) fprintf (stderr, " %c*%d/%d", encchr[e], enc[p][e].s, enc[p][e].t); fprintf (stderr, "\n");
   }
   encoding = safemalloc (l + 1);
   p = 0;
   {
      char cur = E_ASCII;       // starts ASCII
      while (p < l)
      {
         int t,
           m = 0;
         char b = 0;
         for (e = 0; e < E_MAX; e++)
            if (enc[p][e].t && ((t = enc[p][e].t + switchcost[cur][e]) < m || t == m && e == cur || !m))
            {
               b = e;
               m = t;
            }
         cur = b;
         m = enc[p][b].s;
         if (!p && lenp)
            *lenp = enc[p][b].t;
         while (p < l && m--)
            encoding[p++] = encchr[b];
      }
   }
   encoding[p] = 0;
   return encoding;
}

// Main encoding function
// Returns the grid (malloced) containing the matrix. L corner at 0,0.
// Takes suggested size in *Wptr, *Hptr, or 0,0. Fills in actual size.
// Takes barcodelen and barcode to be encoded
// Note, if *encodingptr is null, then fills with auto picked (malloced) encoding
// If lenp not null, then the length of encoded data before any final unlatch or pad is stored
// If maxp not null, then the max storage of this size code is stored
// If eccp not null, then the number of ecc bytes used in this size is stored
// Returns 0 on error (writes to stderr with details).
unsigned char *
iec16022ecc200 (int *Wptr, int *Hptr, char **encodingptr, int barcodelen, unsigned char *barcode, int *lenp, int *maxp, int *eccp)
{
   unsigned char binary[3000];  // encoded raw data and ecc to place in barcode
   int W = 0,
      H = 0;
   char *encoding = 0;
   unsigned char *grid = 0;
   struct ecc200matrix_s *matrix;
   memset (binary, 0, sizeof (binary));
   if (encodingptr)
      encoding = *encodingptr;
   if (Wptr)
      W = *Wptr;
   if (Hptr)
      H = *Hptr;

   // encoding
   if (W)
   {                            // known size
      for (matrix = ecc200matrix; matrix->W && (matrix->W != W || matrix->H != H); matrix++);
      if (!matrix->W)
      {
         fprintf (stderr, "Invalid size %dx%d\n", W, H);
         return 0;
      }
      if (!encoding)
      {
         int len;
         char *e = encmake (barcodelen, barcode, &len, 1);
         if (e && len != matrix->bytes)
         {                      // try not an exact fit
            free (e);
            e = encmake (barcodelen, barcode, &len, 0);
            if (len > matrix->bytes)
            {
               fprintf (stderr, "Cannot make barcode fit %dx%d\n", W, H);
               return 0;
            }
         }
         encoding = e;
      }
   } else
   {                            // find size
      if (encoding)
      {                         // find one that fits chosen encoding
         for (matrix = ecc200matrix; matrix->W; matrix++)
            if (ecc200encode (binary, matrix->bytes, barcode, barcodelen, encoding, 0))
               break;
      } else
      {
         int len;
         char *e;
         e = encmake (barcodelen, barcode, &len, 1);
         for (matrix = ecc200matrix; matrix->W && matrix->bytes != len; matrix++);
         if (e && !matrix->W)
         {                      // try for non exact fit
            free (e);
            e = encmake (barcodelen, barcode, &len, 0);
            for (matrix = ecc200matrix; matrix->W && matrix->bytes < len; matrix++);
         }
         encoding = e;
      }
      if (!matrix->W)
      {
         fprintf (stderr, "Cannot find suitable size, barcode too long\n");
         return 0;
      }
      W = matrix->W;
      H = matrix->H;
   }
   if (!ecc200encode (binary, matrix->bytes, barcode, barcodelen, encoding, lenp))
   {
      fprintf (stderr, "Barcode too long for %dx%d\n", W, H);
      return 0;
   }
   // ecc code
   ecc200 (binary, matrix->bytes, matrix->datablock, matrix->rsblock);
   {                            // placement
      int x,
        y,
        NC,
        NR,
       *places;
      NC = W - 2 * (W / matrix->FW);
      NR = H - 2 * (H / matrix->FH);
      places = safemalloc (NC * NR * sizeof (int));
      ecc200placement (places, NR, NC);
      grid = safemalloc (W * H);
      memset (grid, 0, W * H);
      for (y = 0; y < H; y += matrix->FH)
      {
         for (x = 0; x < W; x++)
            grid[y * W + x] = 1;
         for (x = 0; x < W; x += 2)
            grid[(y + matrix->FH - 1) * W + x] = 1;
      }
      for (x = 0; x < W; x += matrix->FW)
      {
         for (y = 0; y < H; y++)
            grid[y * W + x] = 1;
         for (y = 0; y < H; y += 2)
            grid[y * W + x + matrix->FW - 1] = 1;
      }
      for (y = 0; y < NR; y++)
      {
         for (x = 0; x < NC; x++)
         {
            int v = places[(NR - y - 1) * NC + x];
            //fprintf (stderr, "%4d", v);
            if (v == 1 || v > 7 && (binary[(v >> 3) - 1] & (1 << (v & 7))))
               grid[(1 + y + 2 * (y / (matrix->FH - 2))) * W + 1 + x + 2 * (x / (matrix->FW - 2))] = 1;
         }
         //fprintf (stderr, "\n");
      }
      free (places);
   }
   if (Wptr)
      *Wptr = W;
   if (Hptr)
      *Hptr = H;
   if (encodingptr)
      *encodingptr = encoding;
   if (maxp)
      *maxp = matrix->bytes;
   if (eccp)
      *eccp = (matrix->bytes + 2) / matrix->datablock * matrix->rsblock;
   return grid;
}