transduction

src/aig/gia/gia.h

@@ -1769,10 +1769,14 @@ extern int                 Gia_ManCountPosWithNonZeroDrivers( Gia_Man_t * p );
 extern void                Gia_ManUpdateCopy( Vec_Int_t * vCopy, Gia_Man_t * p );
 extern Vec_Int_t *         Gia_ManComputeDistance( Gia_Man_t * p, int iObj, Vec_Int_t * vObjs, int fVerbose );
 
-/*=== giaTtopt.c ===========================================================*/
+/*=== giaTtopt.cpp ===========================================================*/
 extern Gia_Man_t *         Gia_ManTtopt( Gia_Man_t * p, int nIns, int nOuts, int nRounds );
 extern Gia_Man_t *         Gia_ManTtoptCare( Gia_Man_t * p, int nIns, int nOuts, int nRounds, char * pFileName, int nRarity );
 
+/*=== giaTransduction.cpp ===========================================================*/
+extern Gia_Man_t *         Gia_ManTransductionBdd( Gia_Man_t * pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t * pExdc, int nVerbose );
+extern Gia_Man_t *         Gia_ManTransductionTt( Gia_Man_t * pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t * pExdc, int nVerbose );
+
 /*=== giaCTas.c ===========================================================*/
 typedef struct Tas_Man_t_  Tas_Man_t;
 extern Tas_Man_t *         Tas_ManAlloc( Gia_Man_t * pAig, int nBTLimit );

src/aig/gia/giaNewTt.h

+#ifndef ABC__aig__gia__giaNewTt_h
+#define ABC__aig__gia__giaNewTt_h
+
+#include <limits>
+#include <iomanip>
+#include <iostream>
+#include <vector>
+#include <bitset>
+
+namespace NewTt {
+
+  typedef int                bvar;
+  typedef unsigned           lit;
+  typedef unsigned short     ref;
+  typedef unsigned long long size;
+  
+  static inline bvar BvarMax() { return std::numeric_limits<bvar>::max(); }
+  static inline lit  LitMax()  { return std::numeric_limits<lit>::max();  }
+  static inline ref  RefMax()  { return std::numeric_limits<ref>::max();  }
+  static inline size SizeMax() { return std::numeric_limits<size>::max(); }
+
+  struct Param {
+    int  nObjsAllocLog      = 15;
+    int  nObjsMaxLog        = 20;
+    int  nVerbose           = 0;
+    bool fCountOnes         = false;
+    int  nGbc               = 0;
+    int  nReo               = BvarMax(); // dummy
+  };
+
+  class Man {
+  private:
+    typedef unsigned long long word;
+    typedef std::bitset<64> bsw;
+    static inline int ww() { return 64; } // word width
+    static inline int lww() { return 6; } // log word width
+    static inline word one() {return 0xffffffffffffffffull; }
+    static inline word vars(int i) {
+      static const word vars[] = {0xaaaaaaaaaaaaaaaaull,
+                                  0xccccccccccccccccull,
+                                  0xf0f0f0f0f0f0f0f0ull,
+                                  0xff00ff00ff00ff00ull,
+                                  0xffff0000ffff0000ull,
+                                  0xffffffff00000000ull};
+      return vars[i];
+    }
+    static inline word ones(int i) {
+      static const word ones[] = {0x0000000000000001ull,
+                                  0x0000000000000003ull,
+                                  0x000000000000000full,
+                                  0x00000000000000ffull,
+                                  0x000000000000ffffull,
+                                  0x00000000ffffffffull,
+                                  0xffffffffffffffffull};
+      return ones[i];
+    }
+
+  private:
+    int  nVars;
+    bvar nObjs;
+    bvar nObjsAlloc;
+    bvar nObjsMax;
+    size nSize;
+    size nTotalSize;
+    std::vector<word> vVals;
+    std::vector<bvar> vDeads;
+    std::vector<ref>  vRefs;
+    int nGbc;
+    int nVerbose;
+
+  public:
+    inline lit  Bvar2Lit(bvar a)          const { return (lit)a << 1;        }
+    inline bvar Lit2Bvar(lit x)           const { return (bvar)(x >> 1);     }
+    inline lit  IthVar(int v)             const { return ((lit)v + 1) << 1;  }
+    inline lit  LitNot(lit x)             const { return x ^ (lit)1;         }
+    inline lit  LitNotCond(lit x, bool c) const { return x ^ (lit)c;         }
+    inline bool LitIsCompl(lit x)         const { return x & (lit)1;         }
+    inline ref  Ref(lit x)                const { return vRefs[Lit2Bvar(x)]; }
+    inline lit  Const0()                  const { return (lit)0;             }
+    inline lit  Const1()                  const { return (lit)1;             }
+    inline bool IsConst0(lit x)           const {
+      bvar a = Lit2Bvar(x);
+      word c = LitIsCompl(x)? one(): 0;
+      for(size j = 0; j < nSize; j++)
+        if(vVals[nSize * a + j] ^ c)
+          return false;
+      return true;
+    }
+    inline bool IsConst1(lit x)           const {
+      bvar a = Lit2Bvar(x);
+      word c = LitIsCompl(x)? one(): 0;
+      for(size j = 0; j < nSize; j++)
+        if(~(vVals[nSize * a + j] ^ c))
+          return false;
+      return true;
+    }
+    inline bool LitIsEq(lit x, lit y)     const {
+      if(x == y)
+        return true;
+      if(x == LitMax() || y == LitMax())
+        return false;
+      bvar xvar = Lit2Bvar(x);
+      bvar yvar = Lit2Bvar(y);
+      word c = LitIsCompl(x) ^ LitIsCompl(y)? one(): 0;
+      for(size j = 0; j < nSize; j++)
+        if(vVals[nSize * xvar + j] ^ vVals[nSize * yvar + j] ^ c)
+          return false;
+      return true;
+    }
+    inline size OneCount(lit x)           const {
+      bvar a = Lit2Bvar(x);
+      size count = 0;
+      if(nVars > 6) {
+        for(size j = 0; j < nSize; j++)
+          count += bsw(vVals[nSize * a + j]).count();
+      } else
+        count = bsw(vVals[nSize * a] & ones(nVars)).count();
+      return LitIsCompl(x)? ((size)1 << nVars) - count: count;
+    }
+
+  public:
+    inline void IncRef(lit x) { if(!vRefs.empty() && Ref(x) != RefMax()) vRefs[Lit2Bvar(x)]++; }
+    inline void DecRef(lit x) { if(!vRefs.empty() && Ref(x) != RefMax()) vRefs[Lit2Bvar(x)]--; }
+
+  public:
+    bool Resize() {
+      if(nObjsAlloc == nObjsMax)
+        return false;
+      lit nObjsAllocLit = (lit)nObjsAlloc << 1;
+      if(nObjsAllocLit > (lit)BvarMax())
+        nObjsAlloc = BvarMax();
+      else
+        nObjsAlloc = (bvar)nObjsAllocLit;
+      nTotalSize = nTotalSize << 1;
+      if(nVerbose >= 2)
+        std::cout << "Reallocating " << nObjsAlloc << " nodes" << std::endl;
+      vVals.resize(nTotalSize);
+      if(!vRefs.empty())
+        vRefs.resize(nObjsAlloc);
+      return true;
+    }
+    bool Gbc() {
+      if(nVerbose >= 2)
+        std::cout << "Garbage collect" << std::endl;
+      for(bvar a = nVars + 1; a < nObjs; a++)
+        if(!vRefs[a])
+          vDeads.push_back(a);
+      return vDeads.size();
+    }
+
+  public:
+    Man(int nVars, Param p): nVars(nVars) {
+      if(p.nObjsMaxLog < p.nObjsAllocLog)
+        throw std::invalid_argument("nObjsMax must not be smaller than nObjsAlloc");
+      if(nVars >= lww())
+        nSize = 1 << (nVars - lww());
+      else
+        nSize = 1;
+      if(!nSize)
+        throw std::length_error("Memout (nVars) in init");
+      if(!(nSize << p.nObjsMaxLog))
+        throw std::length_error("Memout (nObjsMax) in init");
+      lit nObjsMaxLit = (lit)1 << p.nObjsMaxLog;
+      if(!nObjsMaxLit)
+        throw std::length_error("Memout (nObjsMax) in init");
+      if(nObjsMaxLit > (lit)BvarMax())
+        nObjsMax = BvarMax();
+      else
+        nObjsMax = (bvar)nObjsMaxLit;
+      lit nObjsAllocLit = (lit)1 << p.nObjsAllocLog;
+      if(!nObjsAllocLit)
+        throw std::length_error("Memout (nObjsAlloc) in init");
+      if(nObjsAllocLit > (lit)BvarMax())
+        nObjsAlloc = BvarMax();
+      else
+        nObjsAlloc = (bvar)nObjsAllocLit;
+      if(nObjsAlloc <= (bvar)nVars)
+        throw std::invalid_argument("nObjsAlloc must be larger than nVars");
+      nTotalSize = nSize << p.nObjsAllocLog;
+      vVals.resize(nTotalSize);
+      if(p.fCountOnes && nVars > 63)
+        throw std::length_error("nVars must be less than 64 to count ones");
+      nObjs = 1;
+      for(int i = 0; i < 6 && i < nVars; i++) {
+        for(size j = 0; j < nSize; j++)
+          vVals[nSize * nObjs + j] = vars(i);
+        nObjs++;
+      }
+      for(int i = 0; i < nVars - 6; i++) {
+        for(size j = 0; j < nSize; j += (2ull << i))
+          for(size k = 0; k < (1ull << i); k++)
+            vVals[nSize * nObjs + j + k] = one();
+        nObjs++;
+      }
+      nVerbose = p.nVerbose;
+      nGbc = p.nGbc;
+      if(nGbc || p.nReo != BvarMax())
+        vRefs.resize(nObjsAlloc);
+    }
+    inline lit And(lit x, lit y) {
+      bvar xvar = Lit2Bvar(x);
+      bvar yvar = Lit2Bvar(y);
+      word xcompl = LitIsCompl(x)? one(): 0;
+      word ycompl = LitIsCompl(y)? one(): 0;
+      unsigned j;
+      if(nObjs >= nObjsAlloc && vDeads.empty()) {
+        bool fRemoved = false;
+        if(nGbc > 1)
+          fRemoved = Gbc();
+        if(!Resize() && !fRemoved && (nGbc != 1 || !Gbc()))
+          throw std::length_error("Memout (node)");
+      }
+      bvar zvar;
+      if(nObjs < nObjsAlloc)
+        zvar = nObjs++;
+      else
+        zvar = vDeads.back(), vDeads.resize(vDeads.size() - 1);
+      for(j = 0; j < nSize; j++)
+        vVals[nSize * zvar + j] = (vVals[nSize * xvar + j] ^ xcompl) & (vVals[nSize * yvar + j] ^ ycompl);
+      return zvar << 1;
+    }
+    inline lit Or(lit x, lit y) {
+      return LitNot(And(LitNot(x), LitNot(y)));
+    }
+    void Reorder() {} // dummy
+
+  public:
+    void SetRef(std::vector<lit> const &vLits) {
+      vRefs.clear();
+      vRefs.resize(nObjsAlloc);
+      for(size_t i = 0; i < vLits.size(); i++)
+        IncRef(vLits[i]);
+    }
+    void TurnOffReo() {
+      if(!nGbc)
+        vRefs.clear();
+    }
+    void PrintNode(lit x) const {
+      bvar a = Lit2Bvar(x);
+      word c = LitIsCompl(x)? one(): 0;
+      for(size j = 0; j < nSize; j++)
+        std::cout << bsw(vVals[nSize * a + j] ^ c);
+      std::cout << std::endl;
+    }
+  };
+
+}
+
+#endif

src/aig/gia/giaTransduction.cpp

+#ifdef _WIN32
+#ifndef __MINGW32__
+#pragma warning(disable : 4786) // warning C4786: identifier was truncated to '255' characters in the browser information
+#endif
+#endif
+
+#include "giaTransduction.h"
+#include "giaNewBdd.h"
+#include "giaNewTt.h"
+
+ABC_NAMESPACE_IMPL_START
+
+Gia_Man_t *Gia_ManTransductionBdd(Gia_Man_t *pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t *pExdc, int nVerbose) {
+  if(nRandom) {
+    srand(nRandom);
+    nSortType = rand() % 4;
+    nPiShuffle = rand();
+    nParameter = rand() % 16;
+  }
+  NewBdd::Param p;
+  Transduction::Transduction<NewBdd::Man, NewBdd::Param, NewBdd::lit, 0xffffffff> t(pGia, nVerbose, nSortType, nPiShuffle, fLevel, pExdc, p);
+  int count = t.CountWires();
+  switch(nType) {
+  case 0:
+    count -= fMspf? t.Mspf(): t.Cspf();
+    break;
+  case 1:
+    count -= t.Resub(fMspf);
+    break;
+  case 2:
+    count -= t.ResubMono(fMspf);
+    break;
+  case 3:
+    count -= t.ResubShared(fMspf);
+    break;
+  case 4:
+    count -= t.RepeatResub(false, fMspf);
+    break;
+  case 5:
+    count -= t.RepeatResub(true, fMspf);
+    break;
+  case 6: {
+    bool fInner = (nParameter / 4) % 2;
+    count -= t.RepeatResubInner(fMspf, fInner);
+    break;
+  }
+  case 7: {
+    bool fInner = (nParameter / 4) % 2;
+    bool fOuter = (nParameter / 8) % 2;
+    count -= t.RepeatResubOuter(fMspf, fInner, fOuter);
+    break;
+  }
+  case 8: {
+    bool fFirstMerge = nParameter % 2;
+    bool fMspfMerge = fMspf? (nParameter / 2) % 2: false;
+    bool fInner = (nParameter / 4) % 2;
+    bool fOuter = (nParameter / 8) % 2;
+    count -= t.Optimize(fFirstMerge, fMspfMerge, fMspf, fInner, fOuter);
+    break;
+  }
+  default:
+    std::cout << "Invalid transduction type" << std::endl;
+    assert(0);
+  }
+  assert(t.Verify());
+  assert(count == t.CountWires());
+  return t.GenerateAig();
+}
+
+Gia_Man_t *Gia_ManTransductionTt(Gia_Man_t *pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t *pExdc, int nVerbose) {
+  if(nRandom) {
+    srand(nRandom);
+    nSortType = rand() % 4;
+    nPiShuffle = rand();
+    nParameter = rand() % 16;
+  }
+  NewTt::Param p;
+  Transduction::Transduction<NewTt::Man, NewTt::Param, NewTt::lit, 0xffffffff> t(pGia, nVerbose, nSortType, nPiShuffle, fLevel, pExdc, p);
+  int count = t.CountWires();
+  switch(nType) {
+  case 0:
+    count -= fMspf? t.Mspf(): t.Cspf();
+    break;
+  case 1:
+    count -= t.Resub(fMspf);
+    break;
+  case 2:
+    count -= t.ResubMono(fMspf);
+    break;
+  case 3:
+    count -= t.ResubShared(fMspf);
+    break;
+  case 4:
+    count -= t.RepeatResub(false, fMspf);
+    break;
+  case 5:
+    count -= t.RepeatResub(true, fMspf);
+    break;
+  case 6: {
+    bool fInner = (nParameter / 4) % 2;
+    count -= t.RepeatResubInner(fMspf, fInner);
+    break;
+  }
+  case 7: {
+    bool fInner = (nParameter / 4) % 2;
+    bool fOuter = (nParameter / 8) % 2;
+    count -= t.RepeatResubOuter(fMspf, fInner, fOuter);
+    break;
+  }
+  case 8: {
+    bool fFirstMerge = nParameter % 2;
+    bool fMspfMerge = fMspf? (nParameter / 2) % 2: false;
+    bool fInner = (nParameter / 4) % 2;
+    bool fOuter = (nParameter / 8) % 2;
+    count -= t.Optimize(fFirstMerge, fMspfMerge, fMspf, fInner, fOuter);
+    break;
+  }
+  default:
+    std::cout << "Invalid transduction type" << std::endl;
+    assert(0);
+  }
+  assert(t.Verify());
+  assert(count == t.CountWires());
+  return t.GenerateAig();
+}
+
+ABC_NAMESPACE_IMPL_END

src/aig/gia/module.make

@@ -103,6 +103,7 @@ SRC +=    src/aig/gia/giaAig.c \
     src/aig/gia/giaSwitch.c \
     src/aig/gia/giaTim.c \
     src/aig/gia/giaTis.c \
+    src/aig/gia/giaTransduction.cpp \
     src/aig/gia/giaTruth.c \
     src/aig/gia/giaTsim.c \
     src/aig/gia/giaTtopt.cpp \

src/base/abci/abc.c

@@ -503,6 +503,7 @@ static int Abc_CommandAbc9LNetEval           ( Abc_Frame_t * pAbc, int argc, cha
 static int Abc_CommandAbc9LNetOpt            ( Abc_Frame_t * pAbc, int argc, char ** argv );
 //#ifndef _WIN32
 static int Abc_CommandAbc9Ttopt              ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandAbc9Transduction       ( Abc_Frame_t * pAbc, int argc, char ** argv );
 //#endif
 static int Abc_CommandAbc9LNetMap            ( Abc_Frame_t * pAbc, int argc, char ** argv );
 static int Abc_CommandAbc9Unmap              ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -1260,6 +1261,7 @@ void Abc_Init( Abc_Frame_t * pAbc )
     Cmd_CommandAdd( pAbc, "ABC9",         "&lnetopt",      Abc_CommandAbc9LNetOpt,      0 );
 //#ifndef _WIN32
     Cmd_CommandAdd( pAbc, "ABC9",         "&ttopt",        Abc_CommandAbc9Ttopt,        0 );
+    Cmd_CommandAdd( pAbc, "ABC9",         "&transduction", Abc_CommandAbc9Transduction, 0 );
 //#endif
     Cmd_CommandAdd( pAbc, "ABC9",         "&lnetmap",      Abc_CommandAbc9LNetMap,      0 );
     Cmd_CommandAdd( pAbc, "ABC9",         "&unmap",        Abc_CommandAbc9Unmap,        0 );
@@ -42581,6 +42583,158 @@ usage:
   SeeAlso     []
 
 ***********************************************************************/
+int Abc_CommandAbc9Transduction( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+    Gia_Man_t * pTemp, * pExdc = NULL;
+    int c, nType = 8, fMspf = 1, nRandom = 0, nSortType = 0, nPiShuffle = 0, nParameter = 0, fLevel = 0, fBdd = 0, nVerbose = 0;
+    Extra_UtilGetoptReset();
+    while ( ( c = Extra_UtilGetopt( argc, argv, "TSIPRVbml" ) ) != EOF )
+    {
+        switch ( c )
+        {
+        case 'T':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-T\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nType = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'R':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-R\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nRandom = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'S':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-S\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nSortType = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'I':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-I\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nPiShuffle = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'P':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-P\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nParameter = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'V':
+            if ( globalUtilOptind >= argc )
+            {
+                Abc_Print( -1, "Command line switch \"-V\" should be followed by a positive integer.\n" );
+                goto usage;
+            }
+            nVerbose = atoi(argv[globalUtilOptind]);
+            globalUtilOptind++;
+            break;
+        case 'b':
+            fBdd ^= 1;
+            break;
+        case 'm':
+            fMspf ^= 1;
+            break;
+        case 'l':
+            fLevel ^= 1;
+            break;
+        case 'h':
+        default:
+            goto usage;
+        }
+    }
+    if ( argc > globalUtilOptind + 1 )
+    {
+        Abc_Print( -1, "Wrong number of auguments.\n" );
+        goto usage;
+    }
+    if ( pAbc->pGia == NULL )
+    {
+        Abc_Print( -1, "Empty GIA network.\n" );
+        return 1;
+    }
+    if ( argc == globalUtilOptind + 1 )
+    {
+        FILE * pFile = fopen( argv[globalUtilOptind], "rb" );
+        if ( pFile == NULL )
+        {
+            Abc_Print( -1, "Cannot open input file \"%s\". ", argv[globalUtilOptind] );
+            return 1;
+        }
+        fclose( pFile );
+        pExdc = Gia_AigerRead( argv[globalUtilOptind], 0, 0, 0 );
+        if ( pExdc == NULL )
+        {
+            Abc_Print( -1, "Reading AIGER has failed.\n" );
+            return 1;
+        }
+    }
+
+    if ( fBdd )
+        pTemp = Gia_ManTransductionBdd( pAbc->pGia, nType, fMspf, nRandom, nSortType, nPiShuffle, nParameter, fLevel, pExdc, nVerbose );
+    else
+        pTemp = Gia_ManTransductionTt( pAbc->pGia, nType, fMspf, nRandom, nSortType, nPiShuffle, nParameter, fLevel, pExdc, nVerbose );
+    if ( pExdc != NULL )
+        Gia_ManStop( pExdc );
+    Abc_FrameUpdateGia( pAbc, pTemp );
+    return 0;
+
+usage:
+    Abc_Print( -2, "usage: &transduction [-TSIPRV num] [-bmlh] <file>\n" );
+    Abc_Print( -2, "\t           performs transduction-based AIG optimization\n" );
+    Abc_Print( -2, "\t-T num   : transduction type [default = %d]\n",                                  nType );
+    Abc_Print( -2, "\t                0: remove simply redundant nodes\n" );
+    Abc_Print( -2, "\t                1: Resub\n" );
+    Abc_Print( -2, "\t                2: ResubMono\n" );
+    Abc_Print( -2, "\t                3: ResubShared\n" );
+    Abc_Print( -2, "\t                4: repeat Resub\n" );
+    Abc_Print( -2, "\t                5: repeat ResubMono\n" );
+    Abc_Print( -2, "\t                6: RepeatResubInner\n" );
+    Abc_Print( -2, "\t                7: RepeatResubOuter\n" );
+    Abc_Print( -2, "\t                8: Optimize\n" );
+    Abc_Print( -2, "\t-S num   : fanin sort type [default = %d]\n",                                    nSortType );
+    Abc_Print( -2, "\t-I num   : random seed to shuffle pis (0 = no shuffle) [default = %d]\n",        nPiShuffle );
+    Abc_Print( -2, "\t-P num   : internal parameter [default = %d]\n",                                 nParameter );
+    Abc_Print( -2, "\t-R num   : random seed to set all parameters (0 = no random) ([default = %d]\n", nRandom );
+    Abc_Print( -2, "\t-V num   : verbosity level [default = %d]\n",                                    nVerbose);
+    Abc_Print( -2, "\t-b       : toggles using BDD instead of truth table [default = %s]\n", fBdd? "yes": "no" );
+    Abc_Print( -2, "\t-m       : toggles using MSPF [default = %s]\n", fMspf? "yes": "no" );
+    Abc_Print( -2, "\t-l       : toggles level preserving optimization [default = %s]\n", fLevel? "yes": "no" );
+    Abc_Print( -2, "\t-h       : prints the command usage\n");
+    Abc_Print( -2, "\t<file>   : AIGER specifying external don't-cares\n");
+    Abc_Print( -2, "\t\n" );
+    Abc_Print( -2, "\t           This command was contributed by Yukio Miyasaka.\n" );
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
 int Abc_CommandAbc9LNetMap( Abc_Frame_t * pAbc, int argc, char ** argv )
 {
     extern Abc_Ntk_t * Gia_ManPerformLNetMap( Gia_Man_t * p, int GroupSize, int fUseFixed, int fTryNew, int fVerbose );