diff --git a/ZString.cpp b/ZString.cpp
index d5ee756..8d64c0d 100644
--- a/ZString.cpp
+++ b/ZString.cpp
@@ -54,24 +54,29 @@ namespace coreutils {
    bool ZString::operator<(const ZString &valuex) const {
       return (strncmp(cursor, valuex.cursor, (valuex.length <= length ? valuex.length : length)) < 0);
    }
-
-   bool ZString::operator>(const ZString &valuex) const
-   {
+   
+   bool ZString::operator>(const ZString &valuex) const {
       return (strncmp(data, valuex.data, valuex.length <= length ? valuex.length : length) > 0);
    }
-
-   bool ZString::operator==(const ZString &valuex) const
-   {
+   
+   bool ZString::operator==(const ZString &valuex) const {
       return (strncmp(data, valuex.data, valuex.length <= length ? valuex.length : length) == 0);
    }
 
-   std::vector<ZString> &ZString::getList()
-   {
+   bool ZString::operator!=(const ZString &valuex) const {
+      return (strncmp(data, valuex.data, valuex.length <= length ? valuex.length : length) != 0);
+   }
+
+   bool ZString::operator!=(const char *valuex) const {
+      size_t len = strlen(valuex);
+      return (strncmp(data, valuex, len <= length ? len : length) != 0);
+   }
+
+   std::vector<ZString> &ZString::getList() {
       return list;
    }
 
-   int ZString::asInteger()
-   {
+   int ZString::asInteger() {
       std::stringstream temp(std::string(data, length));
       int tempInt = 0;
       temp >> tempInt;
@@ -96,13 +101,11 @@ namespace coreutils {
       stack.pop();      
    }
       
-   std::string ZString::str()
-   {
+   std::string ZString::str() {
       return std::string(data, length);
    }
 
-   std::string ZString::str(int len)
-   {
+   std::string ZString::str(int len) {
       return std::string(data, len);
    }
 
@@ -113,8 +116,7 @@ namespace coreutils {
       return cdata;
    }   
    
-   std::vector<ZString> &ZString::split(std::string delimiter, size_t maxSize)
-   {
+   std::vector<ZString> &ZString::split(std::string delimiter, size_t maxSize) {
       coreutils::ZString zDelimiter((char *)delimiter.c_str(), delimiter.size());
       return split(zDelimiter, maxSize);
    }
@@ -129,15 +131,13 @@ namespace coreutils {
       char *end = data + length;
       char *pos = cursor;
       while ((pos + delimiter.getLength()) <= end) {
-         if ((strncmp(pos, delimiter.getData(), delimiter.getLength()) == 0) && (maxSize != 0))
-         {
+         if ((strncmp(pos, delimiter.getData(), delimiter.getLength()) == 0) && (maxSize != 0)) {
             list.push_back(ZString(cursor, pos - cursor));
             cursor = pos + delimiter.getLength();
             pos = cursor;
 	    --maxSize;
          }
-         else
-         {
+         else {
             ++pos;
          }
       }
@@ -145,46 +145,39 @@ namespace coreutils {
       cursor = pos;
       return list;
    }
-
-   bool ZString::isCharacter(char ch, const char *string)
-   {
+   
+   bool ZString::isCharacter(char ch, const char *string) {
       int len = strlen(string);
-      for (int ix = 0; ix < len; ++ix)
-      {
+      for (int ix = 0; ix < len; ++ix) {
          if (ch == string[ix])
-            return true;
+	   return true;
       }
       return false;
    }
 
-   ZString ZString::getTokenInclude(const char *include)
-   {
+   ZString ZString::getTokenInclude(const char *include) {
       char *start = cursor;
       while ((cursor <= (data + length)) && isCharacter(*cursor, include))
-         ++cursor;
+	++cursor;
       return ZString(start, cursor - start);
    }
 
-   ZString ZString::getTokenExclude(const char *exclude)
-   {
+   ZString ZString::getTokenExclude(const char *exclude) {
       char *start = cursor;
       while ((cursor <= (data + length)) && !isCharacter(*cursor, exclude))
-         ++cursor;
+	++cursor;
       return ZString(start, cursor - start);
    }
-
-   ZString ZString::getTokenExclude(std::string exclude)
-   {
+   
+   ZString ZString::getTokenExclude(std::string exclude) {
       return getTokenExclude(exclude.c_str());
    }
 
-   ZString &ZString::operator[](int index)
-   {
+   ZString &ZString::operator[](int index) {
       return list[index];
    }
 
-   bool ZString::eod()
-   {
+   bool ZString::eod() {
       return cursor >= data + length;
    }
 
@@ -192,93 +185,79 @@ namespace coreutils {
       return strncmp(cursor, value, strlen(value)) == 0;
    }
 
-   bool ZString::equals(const char *value)
-   {
+   bool ZString::equals(const char *value) {
       if (strlen(value) != length)
-         return false;
+	return false;
+      return strncmp(data, value, length) == 0;
+   }
+   
+   bool ZString::equals(char *value) {
+      if (strlen(value) != length)
+	return false;
       return strncmp(data, value, length) == 0;
    }
 
-   bool ZString::equals(char *value)
-   {
-      if (strlen(value) != length)
-         return false;
-      return strncmp(data, value, length) == 0;
-   }
-
-   bool ZString::equals(ZString &zstring)
-   {
+   bool ZString::equals(ZString &zstring) {
       if (zstring.getLength() != length)
-         return false;
+	return false;
       return strncmp(data, zstring.getData(), length) == 0;
    }
 
-   bool ZString::equals(std::string &string)
-   {
+   bool ZString::equals(std::string &string) {
       return string == std::string(data, length);
    }
 
-   bool ZString::ifNext(const char *value)
-   {
+   bool ZString::ifNext(const char *value) {
       if (((data + length) - cursor) < strlen(value))
-         return false;
+	return false;
       bool test = (strncmp(cursor, value, strlen(value)) == 0);
       if (test)
-         cursor += strlen(value);
+	cursor += strlen(value);
       return test;
    }
 
    bool ZString::ifNext(ZString &value) {
       if (((data + length) - cursor) < value.getLength())
-         return false;
+	return false;
       bool test = (strncmp(cursor, value.getCursor(), value.getLength()) == 0);
       if (test)
-         cursor += value.getLength();
+	cursor += value.getLength();
       return test;      
    }   
    
-   int ZString::ifEqualsCount(ZString &comparator)
-   {
+   int ZString::ifEqualsCount(ZString &comparator) {
       int count = 0;
-      while (cursor < (data + length))
-      {
-         if (*cursor == *comparator.cursor)
-         {
+      while (cursor < (data + length)) {
+         if (*cursor == *comparator.cursor) {
             ++count;
             ++cursor;
             ++comparator.cursor;
          }
-         else
-         {
+         else {
             return count;
          }
       }
       return count;
    }
-
-   int ZString::skipWhitespace()
-   {
+   
+   int ZString::skipWhitespace() {
       int len = strspn(cursor, " \n\t");
       cursor += len;
       return len;
    }
 
-   ZString ZString::goeol()
-   {
+   ZString ZString::goeol() {
       bool set = false;
       char *temp = cursor;
       char *tempend = data + length;
-      while (cursor <= (data + length))
-      {
-         if (*cursor == '\r')
-         {
+      while (cursor <= (data + length)) {
+         if (*cursor == '\r') {
             tempend = cursor++;
             set = true;
          }
-         if (*cursor == '\n')
-         {
+         if (*cursor == '\n') {
             if (!set)
-               tempend = cursor;
+	      tempend = cursor;
             ++cursor;
             break;
          }
@@ -286,19 +265,17 @@ namespace coreutils {
       }
       return ZString(temp, tempend - temp);
    }
-
-   ZString ZString::readBlock(size_t size)
-   {
+   
+   ZString ZString::readBlock(size_t size) {
       char *temp = cursor;
       cursor += size;
       return ZString(temp, size);
    }
-
-   char *ZString::getData()
-   {
+   
+   char *ZString::getData() {
       return data;
    }
-
+   
    char *ZString::getCursor() {
       return cursor;
    }
@@ -309,18 +286,16 @@ namespace coreutils {
       this->cursor = cursor;
    }
    
-   size_t ZString::getLength()
-   {
+   size_t ZString::getLength() {
       return length - (cursor - data);
    }
-
-   void ZString::setZString(ZString zstring)
-   {
+   
+   void ZString::setZString(ZString zstring) {
       data = zstring.getData();
       length = zstring.getLength();
       cursor = data;
    }
-
+   
    ZString ZString::parsed() {
       return ZString(data, cursor - data);
    }
@@ -329,28 +304,25 @@ namespace coreutils {
       return ZString(cursor, data + length - cursor);
    }
 
-   void ZString::reset()
-   {
+   void ZString::reset() {
       cursor = data;
    }
 
-   char ZString::charAt(int index)
-   {
+   char ZString::charAt(int index) {
       return *(cursor + index);
    }
 
-   bool ZString::ifCRLF()
-   {
+   bool ZString::ifCRLF() {
       int len = length;
       if (*(data + length - 1)  == '\n')
-         --length;
+	--length;
       if (*(data + length - 1) == '\r')
-         --length;
+	--length;
       if (cursor >= (data + length))
-         cursor = data + length;
+	cursor = data + length;
       return len != length;
    }
-
+   
    void ZString::nextChar() {
       if(!eod())
 	++cursor;
diff --git a/ZString.h b/ZString.h
index 629dd9f..f544d26 100644
--- a/ZString.h
+++ b/ZString.h
@@ -85,6 +85,8 @@ namespace coreutils {
       bool operator<(const ZString &valuex) const;
       bool operator>(const ZString &valuex) const;
       bool operator==(const ZString &valuex) const;
+      bool operator!=(const ZString &valuex) const;
+      bool operator!=(const char *valuex) const;
 
       ///
       /// Return a vector of ZString objects which contain the parts established