#
#=DESCRIPTION test valid overlapping x mods
#=EXRESULT PASS
#
/usr/bin/foo {
  /1/1exact px,
  /1/1*     ix,
  /1/2exact px,
  /1/2*     ux,
  /1/3exact px,
  /1/3*     Px,
  /1/4exact px,
  /1/4*     Ux,
  /1/5exact px,
  /1/5*     pix,

  /2/1exact ix,
  /2/1*     px,
  /2/2exact ix,
  /2/2*     ux,
  /2/3exact ix,
  /2/3*     Px,
  /2/4exact ix,
  /2/4*     Ux,
  /2/5exact ix,
  /2/5*     pix,

  /3/1exact ux,
  /3/1*     ix,
  /3/2exact ux,
  /3/2*     px,
  /3/3exact ux,
  /3/3*     Px,
  /3/4exact ux,
  /3/4*     Ux,
  /3/5exact ux,
  /3/5*     pix,

  /4/1exact pix,
  /4/1*     ix,
  /4/2exact pix,
  /4/2*     ux,
  /4/3exact pix,
  /4/3*     px,
  /4/4exact pix,
  /4/4*     Ux,
  /4/5exact pix,
  /4/5*     Px,


  /5/1exact px,
  /5/1**    ix,
  /5/2exact px,
  /5/2**    ux,
  /5/3exact px,
  /5/3**    Px,
  /5/4exact px,
  /5/4**    Ux,
  /5/5exact px,
  /5/5**    pix,

  /6/1exact ix,
  /6/1**    px,
  /6/2exact ix,
  /6/2**    ux,
  /6/3exact ix,
  /6/3**    Px,
  /6/4exact ix,
  /6/4**    Ux,
  /6/5exact ix,
  /6/5**    pix,

  /7/1exact ux,
  /7/1**    ix,
  /7/2exact ux,
  /7/2**    px,
  /7/3exact ux,
  /7/3**    Px,
  /7/4exact ux,
  /7/4**    Ux,
  /7/5exact ux,
  /7/5**    pix,

  /8/1exact pix,
  /8/1**    ix,
  /8/2exact pix,
  /8/2**    ux,
  /8/3exact pix,
  /8/3**    px,
  /8/4exact pix,
  /8/4**    Ux,
  /8/5exact pix,
  /8/5**    Px,


  /9/1exact  px,
  /9/1exac?  ix,
  /9/2exact  px,
  /9/2exac?  ux,
  /9/3exact  px,
  /9/3exac?  Px,
  /9/4exact  px,
  /9/4exac?  Ux,
  /9/5exact  px,
  /9/5exac?  pix,

  /a/1exact  ix,
  /a/1exac?  px,
  /a/2exact  ix,
  /a/2exac?  ux,
  /a/3exact  ix,
  /a/3exac?  Px,
  /a/4exact  ix,
  /a/4exac?  Ux,
  /a/5exact  ix,
  /a/5exac?  pix,

  /b/1exact  ux,
  /b/1exac?  ix,
  /b/2exact  ux,
  /b/2exac?  px,
  /b/3exact  ux,
  /b/3exac?  Px,
  /b/4exact  ux,
  /b/4exac?  Ux,
  /b/5exact  ux,
  /b/5exac?  pix,

  /c/1exact  pix,
  /c/1exac?  ix,
  /c/2exact  pix,
  /c/2exac?  ux,
  /c/3exact  pix,
  /c/3exac?  px,
  /c/4exact  pix,
  /c/4exac?  Ux,
  /c/5exact  pix,
  /c/5exac?  Px,
}
