Fixed a typo in variable names.

20 files changed, 98 insertions, 98 deletions

diff --git a/src/base/abci/abc.c b/src/base/abci/abc.c
index 6992edcf..fce7c6dd 100644
--- a/src/base/abci/abc.c
+++ b/src/base/abci/abc.c
@@ -36329,7 +36329,7 @@ usage:
     Abc_Print( -2, "\t            Functional variables: {a,b} (both a and b are always present)\n");
     Abc_Print( -2, "\t            Parameter variables: {p,q,r,s,t,u,v,w} (any number from 1 to 8)\n");
     Abc_Print( -2, "\t            Boolean operators: AND(&), OR(|), XOR(^), MUX(?:), NOT(~)\n");
-    Abc_Print( -2, "\t            Parantheses should be used around each operator. Spaces not allowed.\n");
+    Abc_Print( -2, "\t            Parentheses should be used around each operator. Spaces not allowed.\n");
     Abc_Print( -2, "\t            Complement (~) is only allowed before variables (use DeMorgan law).\n");
     Abc_Print( -2, "\t            Examples:\n");
     Abc_Print( -2, "\t              (((a&b)&~p)|q)        stuck-at-0/1 at the output\n");
diff --git a/src/base/io/io.c b/src/base/io/io.c
index bf01c7b5..41b08e68 100644
--- a/src/base/io/io.c
+++ b/src/base/io/io.c
@@ -706,7 +706,7 @@ usage:
     fprintf( pAbc->Err, "\t          (in this case CA=11001010 is truth table of MUX(Data0,Data1,Ctrl))\n" );
     fprintf( pAbc->Err, "\t          The lower chars (a,b,c,etc) are reserved for elementary variables.\n" );
     fprintf( pAbc->Err, "\t          The upper chars (A,B,C,etc) are reserved for hexadecimal digits.\n" );
-    fprintf( pAbc->Err, "\t          No spaces are allowed in formulas. In parantheses, LSB goes first.\n" );
+    fprintf( pAbc->Err, "\t          No spaces are allowed in formulas. In parentheses, LSB goes first.\n" );
     return 1;
 }
 
diff --git a/src/base/io/ioReadDsd.c b/src/base/io/ioReadDsd.c
index 514c664a..09845699 100644
--- a/src/base/io/ioReadDsd.c
+++ b/src/base/io/ioReadDsd.c
@@ -90,17 +90,17 @@ int Io_ReadDsdStrSplit( char * pCur, char * pParts[], int * pTypeXor )
             // skip hex truth table
             while ( (*pCur >= '0' && *pCur <= '9') || (*pCur >= 'A' && *pCur <= 'F') )
                 pCur++;
-            // process parantheses
+            // process parentheses
             if ( *pCur != '(' )
             {
-                printf( "Cannot find the opening paranthesis.\n" );
+                printf( "Cannot find the opening parenthesis.\n" );
                 break;
             }
-            // find the corresponding closing paranthesis
+            // find the corresponding closing parenthesis
             pCur = Io_ReadDsdFindEnd( pCur );
             if ( pCur == NULL )
             {
-                printf( "Cannot find the closing paranthesis.\n" );
+                printf( "Cannot find the closing parenthesis.\n" );
                 break;
             }
             pCur++;
@@ -254,7 +254,7 @@ Abc_Ntk_t * Io_ReadDsd( char * pForm )
         Abc_ObjAssignName( Abc_NtkCreatePi(pNtk), (char *)Vec_PtrEntry(vNames, i), NULL );
     Abc_NodeFreeNames( vNames );
 
-    // transform the formula by inserting parantheses
+    // transform the formula by inserting parentheses
     // this transforms strings like PRIME(a,b,cd) into (PRIME((a),(b),(cd)))
     pCur = pFormCopy = ABC_ALLOC( char, 3 * strlen(pForm) + 10 );
     *pCur++ = '(';
diff --git a/src/base/io/ioWriteBench.c b/src/base/io/ioWriteBench.c
index 4ca1ac0a..81d64582 100644
--- a/src/base/io/ioWriteBench.c
+++ b/src/base/io/ioWriteBench.c
@@ -57,7 +57,7 @@ int Io_WriteBench( Abc_Ntk_t * pNtk, const char * pFileName )
     assert( Abc_NtkIsSopNetlist(pNtk) );
     if ( !Io_WriteBenchCheckNames(pNtk) )
     {
-        fprintf( stdout, "Io_WriteBench(): Signal names in this benchmark contain parantheses making them impossible to reproduce in the BENCH format. Use \"short_names\".\n" );
+        fprintf( stdout, "Io_WriteBench(): Signal names in this benchmark contain parentheses making them impossible to reproduce in the BENCH format. Use \"short_names\".\n" );
         return 0;
     }
     pFile = fopen( pFileName, "w" );
@@ -179,7 +179,7 @@ int Io_WriteBenchLut( Abc_Ntk_t * pNtk, char * pFileName )
     assert( Abc_NtkIsAigNetlist(pNtk) );
     if ( !Io_WriteBenchCheckNames(pNtk) )
     {
-        fprintf( stdout, "Io_WriteBenchLut(): Signal names in this benchmark contain parantheses making them impossible to reproduce in the BENCH format. Use \"short_names\".\n" );
+        fprintf( stdout, "Io_WriteBenchLut(): Signal names in this benchmark contain parentheses making them impossible to reproduce in the BENCH format. Use \"short_names\".\n" );
         return 0;
     }
     pFile = fopen( pFileName, "w" );
diff --git a/src/base/io/ioWriteEqn.c b/src/base/io/ioWriteEqn.c
index d3784187..fb8ca43e 100644
--- a/src/base/io/ioWriteEqn.c
+++ b/src/base/io/ioWriteEqn.c
@@ -219,7 +219,7 @@ int Io_NtkWriteEqnCheck( Abc_Ntk_t * pNtk )
     int i, k, Length;
     int RetValue = 1;
 
-    // make sure the network does not have proper names, such as "0" or "1" or containing parantheses
+    // make sure the network does not have proper names, such as "0" or "1" or containing parentheses
     Abc_NtkForEachObj( pNtk, pObj, i )
     {
         pName = Nm_ManFindNameById(pNtk->pManName, i);
diff --git a/src/base/io/ioWriteList.c b/src/base/io/ioWriteList.c
index 22d0d1af..9e0ac88e 100644
--- a/src/base/io/ioWriteList.c
+++ b/src/base/io/ioWriteList.c
@@ -38,7 +38,7 @@ used it in order to reason on relatively small weighed direct graphs. I
 simply list all vertices, one per line and for each vertex "V_source" I
 list all vertices that are "sinks" with respect to it, i.e. such that
 there is a distinct arc between "V_source" and each of them (in
-paranthesis I list the name of the edge and its weight (number of latency
+parenthesis I list the name of the edge and its weight (number of latency
 on that path). For instance, if you look at the following graph, you have
 that vertex "v_5" is connected to vertex "v_6" through a directed arc
 called "v_5_to_v_6" whose latency is equal to 3, i.e. there are three
diff --git a/src/base/io/ioWriteSmv.c b/src/base/io/ioWriteSmv.c
index c767bcaa..5cb82da8 100644
--- a/src/base/io/ioWriteSmv.c
+++ b/src/base/io/ioWriteSmv.c
@@ -75,7 +75,7 @@ int Io_WriteSmv( Abc_Ntk_t * pNtk, char * pFileName )
     assert( Abc_NtkIsSopNetlist(pNtk) );
     if ( !Io_WriteSmvCheckNames(pNtk) )
     {
-        fprintf( stdout, "Io_WriteSmv(): Signal names in this benchmark contain parantheses making them impossible to reproduce in the SMV format. Use \"short_names\".\n" );
+        fprintf( stdout, "Io_WriteSmv(): Signal names in this benchmark contain parentheses making them impossible to reproduce in the SMV format. Use \"short_names\".\n" );
         return 0;
     }
     pFile = fopen( pFileName, "w" );
diff --git a/src/base/ver/verCore.c b/src/base/ver/verCore.c
index 1ac576aa..8ffad68b 100644
--- a/src/base/ver/verCore.c
+++ b/src/base/ver/verCore.c
@@ -412,7 +412,7 @@ int Ver_ParseModule( Ver_Man_t * pMan )
     // get the network with this name
     pNtk = Ver_ParseFindOrCreateNetwork( pMan, pWord );
 
-    // make sure we stopped at the opening paranthesis
+    // make sure we stopped at the opening parenthesis
     if ( Ver_StreamPopChar(p) != '(' )
     {
         sprintf( pMan->sError, "Cannot find \"(\" after \"module\" in network %s.", pNtk->pName );
@@ -420,7 +420,7 @@ int Ver_ParseModule( Ver_Man_t * pMan )
         return 0;
     }
 
-    // skip to the end of parantheses
+    // skip to the end of parentheses
     do {
         if ( Ver_ParseGetName( pMan ) == NULL )
             return 0;
@@ -432,7 +432,7 @@ int Ver_ParseModule( Ver_Man_t * pMan )
     Symbol = Ver_StreamPopChar(p);
     if ( Symbol != ';' )
     {
-        sprintf( pMan->sError, "Expected closing paranthesis after \"module\"." );
+        sprintf( pMan->sError, "Expected closing parenthesis after \"module\"." );
         Ver_ParsePrintErrorMessage( pMan );
         return 0;
     }
@@ -654,7 +654,7 @@ int Ver_ParseSignalPrefix( Ver_Man_t * pMan, char ** ppWord, int * pnMsb, int *
     {
         assert( *pWord == ':' );
         nLsb = atoi( pWord + 1 );
-        // find the closing paranthesis
+        // find the closing parenthesis
         while ( *pWord && *pWord != ']' )
             pWord++;
         if ( *pWord == 0 )
@@ -1340,7 +1340,7 @@ int Ver_ParseGateStandard( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Ver_GateType_t Ga
     // this is gate name - throw it away
     if ( Ver_StreamPopChar(p) != '(' )
     {
-        sprintf( pMan->sError, "Cannot parse a standard gate (expected opening paranthesis)." );
+        sprintf( pMan->sError, "Cannot parse a standard gate (expected opening parenthesis)." );
         Ver_ParsePrintErrorMessage( pMan );
         return 0;
     }
@@ -1377,7 +1377,7 @@ int Ver_ParseGateStandard( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Ver_GateType_t Ga
         // skip comma
         if ( Symbol != ',' )
         {
-            sprintf( pMan->sError, "Cannot parse a standard gate %s (expected closing paranthesis).", Abc_ObjName(Abc_ObjFanout0(pNode)) );
+            sprintf( pMan->sError, "Cannot parse a standard gate %s (expected closing parenthesis).", Abc_ObjName(Abc_ObjFanout0(pNode)) );
             Ver_ParsePrintErrorMessage( pMan );
             return 0;
         }
@@ -1436,7 +1436,7 @@ int Ver_ParseFlopStandard( Ver_Man_t * pMan, Abc_Ntk_t * pNtk )
     // this is gate name - throw it away
     if ( Ver_StreamPopChar(p) != '(' )
     {
-        sprintf( pMan->sError, "Cannot parse a standard gate (expected opening paranthesis)." );
+        sprintf( pMan->sError, "Cannot parse a standard gate (expected opening parenthesis)." );
         Ver_ParsePrintErrorMessage( pMan );
         return 0;
     }
@@ -1573,7 +1573,7 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Mio_Gate_t * pGate )
     // this is gate name - throw it away
     if ( Ver_StreamPopChar(p) != '(' )
     {
-        sprintf( pMan->sError, "Cannot parse gate %s (expected opening paranthesis).", Mio_GateReadName(pGate) );
+        sprintf( pMan->sError, "Cannot parse gate %s (expected opening parenthesis).", Mio_GateReadName(pGate) );
         Ver_ParsePrintErrorMessage( pMan );
         return 0;
     }
@@ -1613,10 +1613,10 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Mio_Gate_t * pGate )
             return 0;
         }
 
-        // open the paranthesis
+        // open the parenthesis
         if ( Ver_StreamPopChar(p) != '(' )
         {
-            sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected opening paranthesis).", pWord, Mio_GateReadName(pGate) );
+            sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected opening parenthesis).", pWord, Mio_GateReadName(pGate) );
             Ver_ParsePrintErrorMessage( pMan );
             return 0;
         }
@@ -1646,10 +1646,10 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Mio_Gate_t * pGate )
             return 0;
         }
 
-        // close the paranthesis
+        // close the parenthesis
         if ( Ver_StreamPopChar(p) != ')' )
         {
-            sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected closing paranthesis).", pWord, Mio_GateReadName(pGate) );
+            sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected closing parenthesis).", pWord, Mio_GateReadName(pGate) );
             Ver_ParsePrintErrorMessage( pMan );
             return 0;
         }
@@ -1678,7 +1678,7 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Mio_Gate_t * pGate )
         // skip comma
         if ( Symbol != ',' )
         {
-            sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected closing paranthesis).", pWord, Mio_GateReadName(pGate) );
+            sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected closing parenthesis).", pWord, Mio_GateReadName(pGate) );
             Ver_ParsePrintErrorMessage( pMan );
             return 0;
         }
@@ -1754,7 +1754,7 @@ int Ver_ParseBox( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkBox )
     // continue parsing the box
     if ( Ver_StreamPopChar(p) != '(' )
     {
-        sprintf( pMan->sError, "Cannot parse box %s (expected opening paranthesis).", Abc_ObjName(pNode) );
+        sprintf( pMan->sError, "Cannot parse box %s (expected opening parenthesis).", Abc_ObjName(pNode) );
         Ver_ParsePrintErrorMessage( pMan );
         return 0;
     }
@@ -1791,10 +1791,10 @@ int Ver_ParseBox( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkBox )
             // save the name
             pBundle->pNameFormal = Extra_UtilStrsav( pWord );
 
-            // open the paranthesis
+            // open the parenthesis
             if ( Ver_StreamPopChar(p) != '(' )
             {
-                sprintf( pMan->sError, "Cannot formal parameter %s of box %s (expected opening paranthesis).", pWord, Abc_ObjName(pNode));
+                sprintf( pMan->sError, "Cannot formal parameter %s of box %s (expected opening parenthesis).", pWord, Abc_ObjName(pNode));
                 Ver_ParsePrintErrorMessage( pMan );
                 return 0;
             }
@@ -2002,11 +2002,11 @@ int Ver_ParseBox( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkBox )
 
         if ( fFormalIsGiven )
         {
-            // close the paranthesis
+            // close the parenthesis
             Ver_ParseSkipComments( pMan );
             if ( Ver_StreamPopChar(p) != ')' )
             {
-                sprintf( pMan->sError, "Cannot parse formal parameter %s of box %s (expected closing paranthesis).", pWord, Abc_ObjName(pNode) );
+                sprintf( pMan->sError, "Cannot parse formal parameter %s of box %s (expected closing parenthesis).", pWord, Abc_ObjName(pNode) );
                 Ver_ParsePrintErrorMessage( pMan );
                 return 0;
             }
@@ -2179,7 +2179,7 @@ int Ver_ParseConnectBox( Ver_Man_t * pMan, Abc_Obj_t * pBox )
             if ( !strcmp(pBundle->pNameFormal, pNameFormal) )
                 break;
         assert( pBundle != NULL );
-        // if the bundle is not found, try without parantheses
+        // if the bundle is not found, try without parentheses
         if ( k == Vec_PtrSize(vBundles) )
         {
             pBundle = NULL;
@@ -2230,7 +2230,7 @@ int Ver_ParseConnectBox( Ver_Man_t * pMan, Abc_Obj_t * pBox )
             if ( !strcmp(pBundle->pNameFormal, pNameFormal) )
                 break;
         assert( pBundle != NULL );
-        // if the name is not found, try without parantheses
+        // if the name is not found, try without parentheses
         if ( k == Vec_PtrSize(vBundles) )
         {
             pBundle = NULL;
diff --git a/src/base/ver/verFormula.c b/src/base/ver/verFormula.c
index bf34b00f..aef62272 100644
--- a/src/base/ver/verFormula.c
+++ b/src/base/ver/verFormula.c
@@ -28,8 +28,8 @@ ABC_NAMESPACE_IMPL_START
 ////////////////////////////////////////////////////////////////////////
 
 // the list of operation symbols to be used in expressions
-#define VER_PARSE_SYM_OPEN    '('   // opening paranthesis
-#define VER_PARSE_SYM_CLOSE   ')'   // closing paranthesis
+#define VER_PARSE_SYM_OPEN    '('   // opening parenthesis
+#define VER_PARSE_SYM_CLOSE   ')'   // closing parenthesis
 #define VER_PARSE_SYM_CONST0  '0'   // constant 0
 #define VER_PARSE_SYM_CONST1  '1'   // constant 1
 #define VER_PARSE_SYM_NEGBEF1 '!'   // negation before the variable
@@ -47,7 +47,7 @@ ABC_NAMESPACE_IMPL_START
 #define VER_PARSE_OPER_OR      4    // logic OR
 #define VER_PARSE_OPER_EQU     3    // equvalence   (a'b'| ab )
 #define VER_PARSE_OPER_MUX     2    // MUX(a,b,c)   (ab | a'c )
-#define VER_PARSE_OPER_MARK    1    // OpStack token standing for an opening paranthesis
+#define VER_PARSE_OPER_MARK    1    // OpStack token standing for an opening parenthesis
 
 // these are values of the internal Flag
 #define VER_PARSE_FLAG_START   1    // after the opening parenthesis 
@@ -91,7 +91,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
     if ( !strcmp(pFormula, "1") || !strcmp(pFormula, "1\'b1") )
         return Hop_ManConst1((Hop_Man_t *)pMan);
 
-    // make sure that the number of opening and closing parantheses is the same
+    // make sure that the number of opening and closing parentheses is the same
     nParans = 0;
     for ( pTemp = pFormula; *pTemp; pTemp++ )
         if ( *pTemp == '(' )
@@ -100,11 +100,11 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
             nParans--;
     if ( nParans != 0 )
     {
-        sprintf( pErrorMessage, "Parse_FormulaParser(): Different number of opening and closing parantheses ()." );
+        sprintf( pErrorMessage, "Parse_FormulaParser(): Different number of opening and closing parentheses ()." );
         return NULL;
     }
  
-    // add parantheses
+    // add parentheses
     pTemp = pFormula + strlen(pFormula) + 2;
     *pTemp-- = 0; *pTemp = ')';
     while ( --pTemp != pFormula )
@@ -186,7 +186,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
         case VER_PARSE_SYM_OPEN:
             if ( Flag == VER_PARSE_FLAG_VAR )
             {
-                sprintf( pErrorMessage, "Parse_FormulaParser(): Variable before a paranthesis." );
+                sprintf( pErrorMessage, "Parse_FormulaParser(): Variable before a parenthesis." );
                 Flag = VER_PARSE_FLAG_ERROR; 
                 break;
             }
@@ -202,7 +202,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
                 {
                     if ( !Vec_IntSize( vStackOp ) )
                     {
-                        sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening paranthesis\n" );
+                        sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening parenthesis\n" );
                         Flag = VER_PARSE_FLAG_ERROR; 
                         break;
                     }
@@ -226,7 +226,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
             }
             else
             {
-                sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening paranthesis\n" );
+                sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening parenthesis\n" );
                 Flag = VER_PARSE_FLAG_ERROR; 
                 break;
             }
diff --git a/src/base/ver/verStream.c b/src/base/ver/verStream.c
index 0d16e74d..59706311 100644
--- a/src/base/ver/verStream.c
+++ b/src/base/ver/verStream.c
@@ -48,7 +48,7 @@ struct Ver_Stream_t_
     char *           pBufferEnd;    // the first position not used by currently loaded data
     char *           pBufferStop;   // the position where loading new data will be done
     // tokens given to the user
-    char             pChars[VER_WORD_SIZE+5]; // temporary storage for a word (plus end-of-string and two parantheses)
+    char             pChars[VER_WORD_SIZE+5]; // temporary storage for a word (plus end-of-string and two parentheses)
     int              nChars;        // the total number of characters in the word
     // status of the parser
     int              fStop;         // this flag goes high when the end of file is reached
diff --git a/src/base/wlc/wlcReadVer.c b/src/base/wlc/wlcReadVer.c
index 11d14395..1bcb2517 100644
--- a/src/base/wlc/wlcReadVer.c
+++ b/src/base/wlc/wlcReadVer.c
@@ -193,7 +193,7 @@ static inline char * Wlc_PrsFindSymbolTwo( char * pStr, char Symb, char Symb2 )
             return pStr;
     return NULL;
 }
-static inline char * Wlc_PrsFindClosingParanthesis( char * pStr, char Open, char Close )
+static inline char * Wlc_PrsFindClosingParenthesis( char * pStr, char Open, char Close )
 {
     int Counter = 0;
     int fNotName = 1;
@@ -624,18 +624,18 @@ static inline int Wlc_PrsFindDefinition( Wlc_Prs_t * p, char * pStr, Vec_Int_t *
         if ( Wlc_PrsFindSymbolTwo(pStr, '>', '>') && Wlc_PrsFindSymbolTwo(pStr, '<', '<') )
         {
             // THIS IS A HACK TO DETECT rotating shifters
-            char * pClose = Wlc_PrsFindClosingParanthesis( pStr, '(', ')' );
+            char * pClose = Wlc_PrsFindClosingParenthesis( pStr, '(', ')' );
             if ( pClose == NULL )
-                return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing paranthesis." );
+                return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing parenthesis." );
             *pStr = ' '; *pClose = 0;
             pStr = Wlc_PrsSkipSpaces( pStr );
             fRotating = 1;
         }
         else
         {
-            char * pClose = Wlc_PrsFindClosingParanthesis( pStr, '(', ')' );
+            char * pClose = Wlc_PrsFindClosingParenthesis( pStr, '(', ')' );
             if ( pClose == NULL )
-                return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing paranthesis." );
+                return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing parenthesis." );
             *pStr = *pClose = ' ';
             pStr = Wlc_PrsSkipSpaces( pStr );
         }
@@ -655,13 +655,13 @@ static inline int Wlc_PrsFindDefinition( Wlc_Prs_t * p, char * pStr, Vec_Int_t *
         else if ( pStr[0] == '~' )
             Type = WLC_OBJ_BIT_NOT;
         else assert( 0 );
-        // skip parantheses
+        // skip parentheses
         pStr = Wlc_PrsSkipSpaces( pStr+1 );
         if ( pStr[0] == '(' )
         {
-            char * pClose = Wlc_PrsFindClosingParanthesis( pStr, '(', ')' );
+            char * pClose = Wlc_PrsFindClosingParenthesis( pStr, '(', ')' );
             if ( pClose == NULL )
-                return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing paranthesis." );
+                return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing parenthesis." );
             *pStr = *pClose = ' ';
         }
         if ( !(pStr = Wlc_PrsReadName(p, pStr, vFanins)) )
@@ -1097,7 +1097,7 @@ startword:
                 fFlopOut = (pStart[0] == 'q');
                 pStart = Wlc_PrsFindSymbol( pStart, '(' );
                 if ( pStart == NULL )
-                    return Wlc_PrsWriteErrorMessage( p, pStart, "Cannot read opening paranthesis in the flop description." );
+                    return Wlc_PrsWriteErrorMessage( p, pStart, "Cannot read opening parenthesis in the flop description." );
                 pStart = Wlc_PrsFindName( pStart+1, &pName );
                 if ( pStart == NULL )
                     return Wlc_PrsWriteErrorMessage( p, pStart, "Cannot read name inside flop description." );
diff --git a/src/bdd/parse/parseCore.c b/src/bdd/parse/parseCore.c
index 497d603c..f451d3aa 100644
--- a/src/bdd/parse/parseCore.c
+++ b/src/bdd/parse/parseCore.c
@@ -24,11 +24,11 @@
     and underscores: For example: 1) a&b <+> c'&d => a + b;   
     2) a1 b2 c3' dummy' + (a2+b2')c3 dummy
  2) Constant values 0 and 1 can be used just like normal variables
- 3) Any boolean operator (listed below) and parantheses can be used
+ 3) Any boolean operator (listed below) and parentheses can be used
     any number of times provided there are equal number of opening
-    and closing parantheses.
+    and closing parentheses.
  4) By default, absence of an operator between vars and before and 
-    after parantheses is taken for AND. 
+    after parentheses is taken for AND. 
  5) Both complementation prefix and complementation suffix can be 
     used at the same time (but who needs this?)
  6) Spaces (tabs, end-of-lines) may be inserted anywhere,
@@ -47,8 +47,8 @@ ABC_NAMESPACE_IMPL_START
 
 
 // the list of operation symbols to be used in expressions
-#define PARSE_SYM_OPEN    '('   // opening paranthesis
-#define PARSE_SYM_CLOSE   ')'   // closing paranthesis
+#define PARSE_SYM_OPEN    '('   // opening parenthesis
+#define PARSE_SYM_CLOSE   ')'   // closing parenthesis
 #define PARSE_SYM_LOWER   '['   // shifts one rank down 
 #define PARSE_SYM_RAISE   ']'   // shifts one rank up
 #define PARSE_SYM_CONST0  '0'   // constant 0
@@ -81,7 +81,7 @@ ABC_NAMESPACE_IMPL_START
 #define PARSE_OPER_EQU  6  // equvalence   (a'b'| ab )
 #define PARSE_OPER_FLR  5  // implication  ( a' | b )
 #define PARSE_OPER_FLL  4  // backward imp ( 'b | a )
-#define PARSE_OPER_MARK 1  // OpStack token standing for an opening paranthesis
+#define PARSE_OPER_MARK 1  // OpStack token standing for an opening parenthesis
 
 // these are values of the internal Flag
 #define PARSE_FLAG_START  1 // after the opening parenthesis 
@@ -133,7 +133,7 @@ DdNode * Parse_FormulaParser( FILE * pOutput, char * pFormulaInit, int nVars, in
         return NULL;
     }
 
-    // make sure that the number of opening and closing parantheses is the same
+    // make sure that the number of opening and closing parentheses is the same
     nParans = 0;
     for ( pTemp = pFormulaInit; *pTemp; pTemp++ )
         if ( *pTemp == '(' )
@@ -142,7 +142,7 @@ DdNode * Parse_FormulaParser( FILE * pOutput, char * pFormulaInit, int nVars, in
             nParans--;
     if ( nParans != 0 )
     {
-        fprintf( pOutput, "Parse_FormulaParser(): Different number of opening and closing parantheses ().\n" );
+        fprintf( pOutput, "Parse_FormulaParser(): Different number of opening and closing parentheses ().\n" );
         return NULL;
     }
 
@@ -326,7 +326,7 @@ DdNode * Parse_FormulaParser( FILE * pOutput, char * pFormulaInit, int nVars, in
                 {
                     if ( Parse_StackOpIsEmpty( pStackOp ) )
                     {
-                        fprintf( pOutput, "Parse_FormulaParser(): There is no opening paranthesis\n" );
+                        fprintf( pOutput, "Parse_FormulaParser(): There is no opening parenthesis\n" );
                         Flag = PARSE_FLAG_ERROR; 
                         break;
                     }
@@ -353,7 +353,7 @@ DdNode * Parse_FormulaParser( FILE * pOutput, char * pFormulaInit, int nVars, in
             }
             else
             {
-                fprintf( pOutput, "Parse_FormulaParser(): There is no opening paranthesis\n" );
+                fprintf( pOutput, "Parse_FormulaParser(): There is no opening parenthesis\n" );
                 Flag = PARSE_FLAG_ERROR; 
                 break;
             }
diff --git a/src/bdd/parse/parseEqn.c b/src/bdd/parse/parseEqn.c
index f6d8b220..ac32e528 100644
--- a/src/bdd/parse/parseEqn.c
+++ b/src/bdd/parse/parseEqn.c
@@ -29,8 +29,8 @@ ABC_NAMESPACE_IMPL_START
 
 
 // the list of operation symbols to be used in expressions
-#define PARSE_EQN_SYM_OPEN    '('   // opening paranthesis
-#define PARSE_EQN_SYM_CLOSE   ')'   // closing paranthesis
+#define PARSE_EQN_SYM_OPEN    '('   // opening parenthesis
+#define PARSE_EQN_SYM_CLOSE   ')'   // closing parenthesis
 #define PARSE_EQN_SYM_CONST0  '0'   // constant 0
 #define PARSE_EQN_SYM_CONST1  '1'   // constant 1
 #define PARSE_EQN_SYM_NEG     '!'   // negation before the variable
@@ -41,7 +41,7 @@ ABC_NAMESPACE_IMPL_START
 #define PARSE_EQN_OPER_NEG    10    // negation
 #define PARSE_EQN_OPER_AND     9    // logic AND
 #define PARSE_EQN_OPER_OR      7    // logic OR
-#define PARSE_EQN_OPER_MARK    1    // OpStack token standing for an opening paranthesis
+#define PARSE_EQN_OPER_MARK    1    // OpStack token standing for an opening parenthesis
 
 // these are values of the internal Flag
 #define PARSE_EQN_FLAG_START   1    // after the opening parenthesis 
@@ -80,7 +80,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
     int Oper, Oper1, Oper2;
     int i, v;
 
-    // make sure that the number of opening and closing parantheses is the same
+    // make sure that the number of opening and closing parentheses is the same
     nParans = 0;
     for ( pTemp = pFormInit; *pTemp; pTemp++ )
         if ( *pTemp == '(' )
@@ -89,7 +89,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
             nParans--;
     if ( nParans != 0 )
     {
-        fprintf( pOutput, "Parse_FormulaParserEqn(): Different number of opening and closing parantheses ().\n" );
+        fprintf( pOutput, "Parse_FormulaParserEqn(): Different number of opening and closing parentheses ().\n" );
         return NULL;
     }
 
@@ -158,7 +158,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
             if ( Flag == PARSE_EQN_FLAG_VAR )
             {
 //                Parse_StackOpPush( pStackOp, PARSE_EQN_OPER_AND );
-                fprintf( pOutput, "Parse_FormulaParserEqn(): An opening paranthesis follows a var without operation sign.\n" ); 
+                fprintf( pOutput, "Parse_FormulaParserEqn(): An opening parenthesis follows a var without operation sign.\n" ); 
                 Flag = PARSE_EQN_FLAG_ERROR; 
                 break; 
             }
@@ -173,7 +173,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
                 {
                     if ( Parse_StackOpIsEmpty( pStackOp ) )
                     {
-                        fprintf( pOutput, "Parse_FormulaParserEqn(): There is no opening paranthesis\n" );
+                        fprintf( pOutput, "Parse_FormulaParserEqn(): There is no opening parenthesis\n" );
                         Flag = PARSE_EQN_FLAG_ERROR; 
                         break;
                     }
@@ -194,7 +194,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
             }
             else
             {
-                fprintf( pOutput, "Parse_FormulaParserEqn(): There is no opening paranthesis\n" );
+                fprintf( pOutput, "Parse_FormulaParserEqn(): There is no opening parenthesis\n" );
                 Flag = PARSE_EQN_FLAG_ERROR; 
                 break;
             }
@@ -211,7 +211,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
               {
                     if ( pTemp[i] == PARSE_EQN_SYM_NEG || pTemp[i] == PARSE_EQN_SYM_OPEN )
                     {
-                        fprintf( pOutput, "Parse_FormulaParserEqn(): The negation sign or an opening paranthesis inside the variable name.\n" );
+                        fprintf( pOutput, "Parse_FormulaParserEqn(): The negation sign or an opening parenthesis inside the variable name.\n" );
                         Flag = PARSE_EQN_FLAG_ERROR; 
                         break;
                     }
diff --git a/src/map/amap/amapParse.c b/src/map/amap/amapParse.c
index 6d8b7520..f02cd6cc 100644
--- a/src/map/amap/amapParse.c
+++ b/src/map/amap/amapParse.c
@@ -30,8 +30,8 @@ ABC_NAMESPACE_IMPL_START
 ////////////////////////////////////////////////////////////////////////
 
 // the list of operation symbols to be used in expressions
-#define AMAP_EQN_SYM_OPEN    '('   // opening paranthesis
-#define AMAP_EQN_SYM_CLOSE   ')'   // closing paranthesis
+#define AMAP_EQN_SYM_OPEN    '('   // opening parenthesis
+#define AMAP_EQN_SYM_CLOSE   ')'   // closing parenthesis
 #define AMAP_EQN_SYM_CONST0  '0'   // constant 0
 #define AMAP_EQN_SYM_CONST1  '1'   // constant 1
 #define AMAP_EQN_SYM_NEG     '!'   // negation before the variable
@@ -47,7 +47,7 @@ ABC_NAMESPACE_IMPL_START
 #define AMAP_EQN_OPER_AND     9    // logic AND
 #define AMAP_EQN_OPER_XOR     8    // logic XOR
 #define AMAP_EQN_OPER_OR      7    // logic OR
-#define AMAP_EQN_OPER_MARK    1    // OpStack token standing for an opening paranthesis
+#define AMAP_EQN_OPER_MARK    1    // OpStack token standing for an opening parenthesis
 
 // these are values of the internal Flag
 #define AMAP_EQN_FLAG_START   1    // after the opening parenthesis 
@@ -114,7 +114,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
     int Oper, Oper1, Oper2;
     int i, v;
 
-    // make sure that the number of opening and closing parantheses is the same
+    // make sure that the number of opening and closing parentheses is the same
     nParans = 0;
     for ( pTemp = pFormInit; *pTemp; pTemp++ )
         if ( *pTemp == '(' )
@@ -123,7 +123,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
             nParans--;
     if ( nParans != 0 )
     {
-        fprintf( pOutput, "Amap_ParseFormula(): Different number of opening and closing parantheses ().\n" );
+        fprintf( pOutput, "Amap_ParseFormula(): Different number of opening and closing parentheses ().\n" );
         return NULL;
     }
 
@@ -207,7 +207,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
             if ( Flag == AMAP_EQN_FLAG_VAR )
             {
                 Vec_IntPush( pStackOp, AMAP_EQN_OPER_AND );
-//                fprintf( pOutput, "Amap_ParseFormula(): An opening paranthesis follows a var without operation sign.\n" ); 
+//                fprintf( pOutput, "Amap_ParseFormula(): An opening parenthesis follows a var without operation sign.\n" ); 
 //                Flag = AMAP_EQN_FLAG_ERROR; 
 //              break; 
             }
@@ -222,7 +222,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
                 {
                     if ( Vec_IntSize( pStackOp ) == 0 )
                     {
-                        fprintf( pOutput, "Amap_ParseFormula(): There is no opening paranthesis\n" );
+                        fprintf( pOutput, "Amap_ParseFormula(): There is no opening parenthesis\n" );
                         Flag = AMAP_EQN_FLAG_ERROR; 
                         break;
                     }
@@ -243,7 +243,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
             }
             else
             {
-                fprintf( pOutput, "Amap_ParseFormula(): There is no opening paranthesis\n" );
+                fprintf( pOutput, "Amap_ParseFormula(): There is no opening parenthesis\n" );
                 Flag = AMAP_EQN_FLAG_ERROR; 
                 break;
             }
@@ -262,7 +262,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
               {
                     if ( pTemp[i] == AMAP_EQN_SYM_NEG || pTemp[i] == AMAP_EQN_SYM_OPEN )
                     {
-                        fprintf( pOutput, "Amap_ParseFormula(): The negation sign or an opening paranthesis inside the variable name.\n" );
+                        fprintf( pOutput, "Amap_ParseFormula(): The negation sign or an opening parenthesis inside the variable name.\n" );
                         Flag = AMAP_EQN_FLAG_ERROR; 
                         break;
                     }
diff --git a/src/map/if/ifTune.c b/src/map/if/ifTune.c
index 1f5b13c8..8b7e9d1c 100644
--- a/src/map/if/ifTune.c
+++ b/src/map/if/ifTune.c
@@ -233,7 +233,7 @@ int Ifn_ManStrCheck( char * pStr, int * pnInps, int * pnObjs )
     *pnObjs = MaxVar + 1 + nNodes;
     return 1;
 }
-static inline char * Ifn_NtkParseFindClosingParanthesis( char * pStr, char Open, char Close )
+static inline char * Ifn_NtkParseFindClosingParenthesis( char * pStr, char Open, char Close )
 {
     int Counter = 0;
     assert( *pStr == Open );
@@ -253,7 +253,7 @@ int Ifn_NtkParseInt_rec( char * pStr, Ifn_Ntk_t * p, char ** ppFinal, int * piNo
     Ifn_Obj_t * pObj;
     int nFanins = 0, pFanins[IFN_INS];
     int Type = Inf_ManOpenSymb( pStr );
-    char * pLim = Ifn_NtkParseFindClosingParanthesis( pStr++, Ifn_Symbs[Type][0], Ifn_Symbs[Type][1] );
+    char * pLim = Ifn_NtkParseFindClosingParenthesis( pStr++, Ifn_Symbs[Type][0], Ifn_Symbs[Type][1] );
     *ppFinal = NULL;
     if ( pLim == NULL )
         return Ifn_ErrorMessage( "For symbol \'%c\' cannot find matching symbol \'%c\'.\n", Ifn_Symbs[Type][0], Ifn_Symbs[Type][1] );
diff --git a/src/map/mapper/mapperSuper.c b/src/map/mapper/mapperSuper.c
index 9382575a..0c33d580 100644
--- a/src/map/mapper/mapperSuper.c
+++ b/src/map/mapper/mapperSuper.c
@@ -149,7 +149,7 @@ int Map_LibraryReadFile( Map_SuperLib_t * pLib, FILE * pFile )
         // get the gate
         pGate = Map_LibraryReadGate( pLib, pTemp, pLib->nVarsMax );
         assert( pGate->Num == nCounter + 1 );
-        // count the number of parantheses in the formula - this is the number of gates
+        // count the number of parentheses in the formula - this is the number of gates
         for ( pTemp = pGate->pFormula; *pTemp; pTemp++ )
             pGate->nGates += (*pTemp == '(');
         // verify the truth table
@@ -261,7 +261,7 @@ char * Map_LibraryReadFormulaStep( char * pFormula, char * pStrings[], int * pnS
     // skip leading spaces
     for ( pName = pFormula; *pName && *pName == ' '; pName++ );
     assert( *pName );
-    // find the first opening paranthesis
+    // find the first opening parenthesis
     for ( pPar1 = pName; *pPar1 && *pPar1 != '('; pPar1++ );
     if ( *pPar1 == 0 )
     {
@@ -271,7 +271,7 @@ char * Map_LibraryReadFormulaStep( char * pFormula, char * pStrings[], int * pnS
     // overwrite it with space
     assert( *pPar1 == '(' );
     *pPar1 = 0;
-    // find the corresponding closing paranthesis
+    // find the corresponding closing parenthesis
     for ( CountPars = 1, pPar2 = pPar1 + 1; *pPar2 && CountPars; pPar2++ )
         if ( *pPar2 == '(' )
             CountPars++;
diff --git a/src/map/mio/mioParse.c b/src/map/mio/mioParse.c
index 6d7740a2..eb9cddc0 100644
--- a/src/map/mio/mioParse.c
+++ b/src/map/mio/mioParse.c
@@ -27,8 +27,8 @@ ABC_NAMESPACE_IMPL_START
 ////////////////////////////////////////////////////////////////////////
 
 // the list of operation symbols to be used in expressions
-#define MIO_EQN_SYM_OPEN    '('   // opening paranthesis
-#define MIO_EQN_SYM_CLOSE   ')'   // closing paranthesis
+#define MIO_EQN_SYM_OPEN    '('   // opening parenthesis
+#define MIO_EQN_SYM_CLOSE   ')'   // closing parenthesis
 #define MIO_EQN_SYM_CONST0  '0'   // constant 0
 #define MIO_EQN_SYM_CONST1  '1'   // constant 1
 #define MIO_EQN_SYM_NEG     '!'   // negation before the variable
@@ -44,7 +44,7 @@ ABC_NAMESPACE_IMPL_START
 #define MIO_EQN_OPER_AND     9    // logic AND
 #define MIO_EQN_OPER_XOR     8    // logic XOR
 #define MIO_EQN_OPER_OR      7    // logic OR
-#define MIO_EQN_OPER_MARK    1    // OpStack token standing for an opening paranthesis
+#define MIO_EQN_OPER_MARK    1    // OpStack token standing for an opening parenthesis
 
 // these are values of the internal Flag
 #define MIO_EQN_FLAG_START   1    // after the opening parenthesis 
@@ -114,7 +114,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
     int Oper, Oper1, Oper2;
     int i, v;
 
-    // make sure that the number of opening and closing parantheses is the same
+    // make sure that the number of opening and closing parentheses is the same
     nParans = 0;
     for ( pTemp = pFormInit; *pTemp; pTemp++ )
         if ( *pTemp == '(' )
@@ -123,7 +123,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
             nParans--;
     if ( nParans != 0 )
     {
-        fprintf( stdout, "Mio_ParseFormula(): Different number of opening and closing parantheses ().\n" );
+        fprintf( stdout, "Mio_ParseFormula(): Different number of opening and closing parentheses ().\n" );
         return NULL;
     }
 
@@ -207,7 +207,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
             if ( Flag == MIO_EQN_FLAG_VAR )
             {
                 Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
-//                fprintf( stdout, "Mio_ParseFormula(): An opening paranthesis follows a var without operation sign.\n" ); 
+//                fprintf( stdout, "Mio_ParseFormula(): An opening parenthesis follows a var without operation sign.\n" ); 
 //                Flag = MIO_EQN_FLAG_ERROR; 
 //              break; 
             }
@@ -222,7 +222,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
                 {
                     if ( Vec_IntSize( pStackOp ) == 0 )
                     {
-                        fprintf( stdout, "Mio_ParseFormula(): There is no opening paranthesis\n" );
+                        fprintf( stdout, "Mio_ParseFormula(): There is no opening parenthesis\n" );
                         Flag = MIO_EQN_FLAG_ERROR; 
                         break;
                     }
@@ -243,7 +243,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
             }
             else
             {
-                fprintf( stdout, "Mio_ParseFormula(): There is no opening paranthesis\n" );
+                fprintf( stdout, "Mio_ParseFormula(): There is no opening parenthesis\n" );
                 Flag = MIO_EQN_FLAG_ERROR; 
                 break;
             }
@@ -262,7 +262,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
               {
                     if ( pTemp[i] == MIO_EQN_SYM_NEG || pTemp[i] == MIO_EQN_SYM_OPEN )
                     {
-                        fprintf( stdout, "Mio_ParseFormula(): The negation sign or an opening paranthesis inside the variable name.\n" );
+                        fprintf( stdout, "Mio_ParseFormula(): The negation sign or an opening parenthesis inside the variable name.\n" );
                         Flag = MIO_EQN_FLAG_ERROR; 
                         break;
                     }
diff --git a/src/map/super/superWrite.c b/src/map/super/superWrite.c
index b8d14837..841a465c 100644
--- a/src/map/super/superWrite.c
+++ b/src/map/super/superWrite.c
@@ -35,7 +35,7 @@ ABC_NAMESPACE_IMPL_START
         GATENAME1( GATENAME2( a, c ), GATENAME3( a, d ), ... )
         The gate names (GATENAME1, etc) are the names as they appear in the .genlib library.
         The primary inputs of the gates are denoted by lowercase chars 'a', 'b', etc.
-        The parantheses are mandatory for each gate, except for the wire. 
+        The parentheses are mandatory for each gate, except for the wire. 
         The wire name can be omitted, so that "a" can be used instead of "**wire**( a )".
         The spaces are optional in any position of this string.
 
diff --git a/src/opt/dau/dauMerge.c b/src/opt/dau/dauMerge.c
index fff2e523..534a0237 100644
--- a/src/opt/dau/dauMerge.c
+++ b/src/opt/dau/dauMerge.c
@@ -264,7 +264,7 @@ static inline void Dau_DsdMergeInlineDefinitions( char * pDsd, int * pMatches, D
 
 /**Function*************************************************************
 
-  Synopsis    [Computes independence status for each opening paranthesis.]
+  Synopsis    [Computes independence status for each opening parenthesis.]
 
   Description []
                
diff --git a/src/sat/bmc/bmcFault.c b/src/sat/bmc/bmcFault.c
index 3e3e6ce9..7a2a57fb 100644
--- a/src/sat/bmc/bmcFault.c
+++ b/src/sat/bmc/bmcFault.c
@@ -384,12 +384,12 @@ int Gia_FormStrCount( char * pStr, int * pnVars, int * pnPars )
     int i, Counter = 0;
     if ( pStr[0] != '(' )
     {
-        printf( "The first symbol should be the opening paranthesis \"(\".\n" );
+        printf( "The first symbol should be the opening parenthesis \"(\".\n" );
         return 1;
     }
     if ( pStr[strlen(pStr)-1] != ')' )
     {
-        printf( "The last symbol should be the closing paranthesis \")\".\n" );
+        printf( "The last symbol should be the closing parenthesis \")\".\n" );
         return 1;
     }
     for ( i = 0; pStr[i]; i++ )
@@ -399,7 +399,7 @@ int Gia_FormStrCount( char * pStr, int * pnVars, int * pnPars )
             Counter--;
     if ( Counter != 0 )
     {
-        printf( "The number of opening and closing parantheses is not equal.\n" );
+        printf( "The number of opening and closing parentheses is not equal.\n" );
         return 1;
     }
     *pnVars = 0;