_ZN9OpenBabel6OBBaseD2Ev:
  234|      8|        {
  235|      8|          if (!_vdata.empty())
  ------------------
  |  Branch (235:15): [True: 0, False: 8]
  ------------------
  236|      0|            {
  237|      0|              std::vector<OBGenericData*>::iterator m;
  238|      0|              for (m = _vdata.begin();m != _vdata.end();m++)
  ------------------
  |  Branch (238:39): [True: 0, False: 0]
  ------------------
  239|      0|                delete *m;
  240|      0|              _vdata.clear();
  241|      0|            }
  242|      8|        }
_ZN9OpenBabel6OBBase12CastAndClearINS_5OBMolEEEPT_b:
  267|      6|        {
  268|      6|          T* pOb = dynamic_cast<T*>(this);
  269|      6|          if(pOb && clear)// Clear only if this is of target class
  ------------------
  |  Branch (269:14): [True: 6, False: 0]
  |  Branch (269:21): [True: 6, False: 0]
  ------------------
  270|      6|            Clear();
  271|      6|          return pOb;
  272|      6|        }

_ZN9OpenBabel8OBBitVecC2Ev:
   74|     46|	  :_set(STARTWORDS, 0)
  ------------------
  |  |   45|     46|#define STARTWORDS 10
  ------------------
   75|     46|        { _size = _set.size(); }

_ZN9OpenBabel13OBChargeModel6TypeIDEv:
   37|      8|    const char* TypeID() override { return "charges"; }

_ZN9OpenBabel16OBGlobalDataBaseC2Ev:
   60|      8|      OBGlobalDataBase(): _init(false), _dataptr(nullptr) { }

_ZN9OpenBabel12OBDescriptor6TypeIDEv:
   39|     36|  const char* TypeID() override { return "descriptors"; }

_ZN9OpenBabel13OBFingerprint6TypeIDEv:
   46|     18|	{
   47|     18|		return "fingerprints";
   48|     18|	}

_ZN9OpenBabel12OBForceField6TypeIDEv:
  592|     10|    {
  593|     10|      return "forcefields";
  594|     10|    }

_ZN9OpenBabel8OBFormatC2Ev:
   52|    234|    OBFormat(){}
_ZN9OpenBabel8OBFormat6TypeIDEv:
   54|    322|    const char* TypeID() override { return "formats"; }
_ZN9OpenBabel8OBFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
   62|      1|      { std::cerr << "Not a valid input format"; return false;}
_ZN9OpenBabel8OBFormat5FlagsEv:
  123|     63|    virtual unsigned int Flags() { return 0;};
_ZN9OpenBabel8OBFormat14FormatsMIMEMapEv:
  157|     94|    {
  158|     94|      static PluginMapType m;
  159|     94|      return m;
  160|     94|    }

_ZN9OpenBabel14OBGroupContribC2EPKcS2_S2_:
   55|      6|    : OBDescriptor(ID, false), _filename(filename), _descr(descr), _debug(false){}

_ZN9OpenBabel19LineEndingExtractorclERNSt3__113basic_istreamIcNS1_11char_traitsIcEEEE:
  173|  5.89k|  {
  174|  5.89k|    int ch( src.get() ) ;
  175|  5.89k|    switch (ch)
  176|  5.89k|    {
  177|      4|      case 13: //CR or CRLF
  ------------------
  |  Branch (177:7): [True: 4, False: 5.88k]
  ------------------
  178|      4|        if(src.peek() == 10)
  ------------------
  |  Branch (178:12): [True: 0, False: 4]
  ------------------
  179|      0|          src.get(); //CRLF
  180|       |        //fall through
  181|      7|      case 10: //LF
  ------------------
  |  Branch (181:7): [True: 3, False: 5.88k]
  ------------------
  182|      7|        return '\n';
  183|      0|        break;
  184|  5.88k|      default:
  ------------------
  |  Branch (184:7): [True: 5.88k, False: 7]
  ------------------
  185|  5.88k|        return ch;
  186|  5.89k|    }
  187|  5.89k|  }
_ZN9OpenBabel20FilteringInputStreamINS_19LineEndingExtractorEEC1ERNSt3__113basic_istreamIcNS3_11char_traitsIcEEEE:
  204|      8|        FilteringInputStreambuf<Extractor>(&istream),std::istream(this) {}
_ZN9OpenBabel23FilteringInputStreambufINS_19LineEndingExtractorEEC2EPNSt3__113basic_istreamIcNS3_11char_traitsIcEEEE:
  121|      8|    : mySource(source)
  122|      8|  {
  123|      8|    setg( &myBuffer , &myBuffer , &myBuffer ) ;
  124|      8|  }
_ZN9OpenBabel20FilteringInputStreamINS_19LineEndingExtractorEED2Ev:
  205|      8|    virtual ~FilteringInputStream() {}
_ZN9OpenBabel23FilteringInputStreambufINS_19LineEndingExtractorEE7seekoffExNSt3__18ios_base7seekdirEj:
   75|      8|    {
   76|      8|      setg(  &myBuffer , &myBuffer , &myBuffer  ) ; //ensure next character is from new position
   77|      8|      mySource->seekg(off, way);
   78|      8|      std::streampos ret = mySource->tellg();
   79|       |//      sync();
   80|      8|      return ret;
   81|      8|    };
_ZN9OpenBabel23FilteringInputStreambufINS_19LineEndingExtractorEE9underflowEv:
  130|  5.89k|  {
  131|  5.89k|    int result( EOF ) ;
  132|  5.89k|    if( gptr() < egptr() )
  ------------------
  |  Branch (132:9): [True: 0, False: 5.89k]
  ------------------
  133|      0|      result = *gptr() ;
  134|  5.89k|    else if ( mySource != nullptr )
  ------------------
  |  Branch (134:15): [True: 5.89k, False: 0]
  ------------------
  135|  5.89k|    {
  136|  5.89k|      result = myExtractor( *mySource ) ;
  137|  5.89k|      if ( result != EOF )
  ------------------
  |  Branch (137:12): [True: 5.88k, False: 2]
  ------------------
  138|  5.88k|      {
  139|  5.88k|        if( result < 0 || result > UCHAR_MAX )
  ------------------
  |  Branch (139:13): [True: 0, False: 5.88k]
  |  Branch (139:27): [True: 0, False: 5.88k]
  ------------------
  140|      0|          std::cerr << "FilteringInputStreambuf error" << std::endl;
  141|  5.88k|        myBuffer = static_cast<char>(static_cast<unsigned char>(result)) ;
  142|  5.88k|        setg( &myBuffer , &myBuffer , &myBuffer + 1 ) ;
  143|  5.88k|      }
  144|  5.89k|    }
  145|  5.89k|    return result ;
  146|  5.89k|  }

_ZN9OpenBabel7vector3C2Eddd:
   52|      8|      _vx(inX), _vy(inY), _vz(inZ)
   53|      8|      {}

_ZNK9OpenBabel5OBMol8NumAtomsEv:
  276|      1|    unsigned int NumAtoms() const         {  return(_natoms); }
_ZN9OpenBabel5OBMol5EmptyEv:
  617|     10|    bool Empty()                       { return(_natoms == 0);          }
_ZN9OpenBabel5OBMol12BeginResidueERNSt3__111__wrap_iterIPPNS_9OBResidueEEE:
  703|      8|    {
  704|      8|      i = _residue.begin();
  705|      8|      return((i == _residue.end()) ? nullptr:*i);
  ------------------
  |  Branch (705:14): [True: 8, False: 0]
  ------------------
  706|      8|    }

_ZNK9OpenBabel12OBConversion11GetInStreamEv:
  107|     14|      std::istream* GetInStream() const {return pInput;};
_ZN9OpenBabel12OBConversion11StreamStateC2Ev:
  355|     16|          StreamState(): pStream(nullptr) {}
_ZN9OpenBabel12OBConversion11StreamStateD2Ev:
  357|     16|          {
  358|       |            assert(ownedStreams.size() == 0); //should be popped
  359|     16|          }
_ZNK9OpenBabel12OBConversion11StreamState5isSetEv:
  367|     16|          bool isSet() const { return pStream != nullptr; }

_ZN9OpenBabel16OBMessageHandler11StopLoggingEv:
  128|      8|      void StopLogging()  { _logging = false; }
_ZN9OpenBabel16OBMessageHandler14GetOutputLevelEv:
  142|      6|      obMessageLevel GetOutputLevel() { return _outputLevel; }

_ZN9OpenBabel16OBMoleculeFormatC2Ev:
   62|    218|  {
   63|    218|    if(!OptionsRegistered)
  ------------------
  |  Branch (63:8): [True: 2, False: 216]
  ------------------
   64|      2|    {
   65|      2|      OptionsRegistered=true;
   66|      2|      OBConversion::RegisterOptionParam("b",         this, 0, OBConversion::INOPTIONS);
   67|      2|      OBConversion::RegisterOptionParam("s",         this, 0, OBConversion::INOPTIONS);
   68|      2|      OBConversion::RegisterOptionParam("title",     this, 1, OBConversion::GENOPTIONS);
   69|      2|      OBConversion::RegisterOptionParam("addtotitle",this, 1, OBConversion::GENOPTIONS);
   70|      2|      OBConversion::RegisterOptionParam("property",  this, 2, OBConversion::GENOPTIONS);
   71|      2|      OBConversion::RegisterOptionParam("C",         this, 0, OBConversion::GENOPTIONS);
   72|      2|      OBConversion::RegisterOptionParam("j",         this, 0, OBConversion::GENOPTIONS);
   73|      2|      OBConversion::RegisterOptionParam("join",      this, 0, OBConversion::GENOPTIONS);
   74|      2|      OBConversion::RegisterOptionParam("separate",  this, 0, OBConversion::GENOPTIONS);
   75|       |
   76|       |      //The follow are OBMol options, which should not be in OBConversion.
   77|       |      //But here isn't entirely appropriate either, since one could have
   78|       |      //OBMol formats loaded but which don't derived from this class.
   79|       |      //However, this possibility is remote.
   80|      2|      OBConversion::RegisterOptionParam("s", nullptr, 1,OBConversion::GENOPTIONS);
   81|      2|      OBConversion::RegisterOptionParam("v", nullptr, 1,OBConversion::GENOPTIONS);
   82|      2|      OBConversion::RegisterOptionParam("h", nullptr, 0,OBConversion::GENOPTIONS);
   83|      2|      OBConversion::RegisterOptionParam("d", nullptr, 0,OBConversion::GENOPTIONS);
   84|      2|      OBConversion::RegisterOptionParam("b", nullptr, 0,OBConversion::GENOPTIONS);
   85|      2|      OBConversion::RegisterOptionParam("c", nullptr, 0,OBConversion::GENOPTIONS);
   86|      2|      OBConversion::RegisterOptionParam("p", nullptr, 1,OBConversion::GENOPTIONS);
   87|      2|      OBConversion::RegisterOptionParam("t", nullptr, 0,OBConversion::GENOPTIONS);
   88|      2|      OBConversion::RegisterOptionParam("k", nullptr, 0,OBConversion::GENOPTIONS);
   89|      2|      OBConversion::RegisterOptionParam("filter", nullptr, 1,OBConversion::GENOPTIONS);
   90|      2|      OBConversion::RegisterOptionParam("add", nullptr, 1,OBConversion::GENOPTIONS);
   91|      2|      OBConversion::RegisterOptionParam("delete", nullptr, 1,OBConversion::GENOPTIONS);
   92|      2|      OBConversion::RegisterOptionParam("append", nullptr, 1,OBConversion::GENOPTIONS);
   93|      2|    }
   94|    218|  }
_ZN9OpenBabel16OBMoleculeFormat14ReadChemObjectEPNS_12OBConversionE:
  103|      8|  { return ReadChemObjectImpl(pConv, this);}

_ZN9OpenBabel4OBOp6TypeIDEv:
   41|     36|  const char* TypeID() override { return "ops"; }

_ZN9OpenBabel15OBSmartsPatternC2Ev:
  183|      4|  OBSmartsPattern() : _pat(nullptr), _buffer(nullptr), LexPtr(nullptr), MainPtr(nullptr) { }

_ZNK9OpenBabel11CharPtrLessclEPKcS2_:
   44|  6.13k|  { return strcasecmp(p1,p2)<0; }
_ZN9OpenBabel8OBPlugin9PluginMapEv:
  134|    435|  {
  135|    435|    static PluginMapType m;
  136|    435|    return m;
  137|    435|  }
_ZN9OpenBabel8OBFormat3MapEv:
  197|    661|  static PluginMapType& Map() {\
  198|    661|    static PluginMapType m;\
  199|    661|    return m;\
  200|    661|  }\
_ZNK9OpenBabel8OBFormat6GetMapEv:
  201|    645|  PluginMapType& GetMap() const override {\
  202|    645|    return Map();\
  203|    645|  }\
_ZN9OpenBabel8OBFormat7DefaultEv:
  205|      8|  static BaseClass*& Default() {\
  206|      8|    static BaseClass* d;\
  207|      8|    return d;\
  208|      8|  }\
_ZN9OpenBabel8OBFormat8FindTypeEPKc:
  221|     16|  static BaseClass* FindType(const char* ID) {\
  222|     16|    if (!ID || *ID==0 || *ID==' ') {\
  ------------------
  |  Branch (222:9): [True: 0, False: 16]
  |  Branch (222:16): [True: 0, False: 16]
  |  Branch (222:26): [True: 0, False: 16]
  ------------------
  223|      0|      return Default();\
  224|      0|    }\
  225|     16|    return static_cast<BaseClass*>(BaseFindType(Map(),ID));\
  226|     16|  }
_ZN9OpenBabel4OBOp7DefaultEv:
  205|      2|  static BaseClass*& Default() {\
  206|      2|    static BaseClass* d;\
  207|      2|    return d;\
  208|      2|  }\
_ZN9OpenBabel4OBOp3MapEv:
  197|    108|  static PluginMapType& Map() {\
  198|    108|    static PluginMapType m;\
  199|    108|    return m;\
  200|    108|  }\
_ZN9OpenBabel12OBDescriptor3MapEv:
  197|    108|  static PluginMapType& Map() {\
  198|    108|    static PluginMapType m;\
  199|    108|    return m;\
  200|    108|  }\
_ZN9OpenBabel12OBDescriptor7DefaultEv:
  205|      2|  static BaseClass*& Default() {\
  206|      2|    static BaseClass* d;\
  207|      2|    return d;\
  208|      2|  }\
_ZN9OpenBabel12OBDescriptorC2EPKcb:
  209|     36|  BaseClass(const char* ID, bool IsDefault=false) {\
  210|     36|    _id=ID;\
  211|     36|    if (ID&&*ID) {\
  ------------------
  |  Branch (211:9): [True: 36, False: 0]
  |  Branch (211:13): [True: 36, False: 0]
  ------------------
  212|     36|      if (IsDefault || Map().empty()) {\
  ------------------
  |  Branch (212:11): [True: 0, False: 36]
  |  Branch (212:24): [True: 2, False: 34]
  ------------------
  213|      2|        Default() = this;\
  214|      2|      }\
  215|     36|      if (Map().count(ID) == 0) {\
  ------------------
  |  Branch (215:11): [True: 36, False: 0]
  ------------------
  216|     36|        Map()[ID] = this;\
  217|     36|        PluginMap()[TypeID()] = this;\
  218|     36|      }\
  219|     36|    }\
  220|     36|  }\
_ZN9OpenBabel4OBOpC2EPKcb:
  209|     36|  BaseClass(const char* ID, bool IsDefault=false) {\
  210|     36|    _id=ID;\
  211|     36|    if (ID&&*ID) {\
  ------------------
  |  Branch (211:9): [True: 36, False: 0]
  |  Branch (211:13): [True: 36, False: 0]
  ------------------
  212|     36|      if (IsDefault || Map().empty()) {\
  ------------------
  |  Branch (212:11): [True: 0, False: 36]
  |  Branch (212:24): [True: 2, False: 34]
  ------------------
  213|      2|        Default() = this;\
  214|      2|      }\
  215|     36|      if (Map().count(ID) == 0) {\
  ------------------
  |  Branch (215:11): [True: 36, False: 0]
  ------------------
  216|     36|        Map()[ID] = this;\
  217|     36|        PluginMap()[TypeID()] = this;\
  218|     36|      }\
  219|     36|    }\
  220|     36|  }\
_ZN9OpenBabel13OBFingerprint3MapEv:
  197|     52|  static PluginMapType& Map() {\
  198|     52|    static PluginMapType m;\
  199|     52|    return m;\
  200|     52|  }\
_ZN9OpenBabel13OBFingerprint7DefaultEv:
  205|      2|  static BaseClass*& Default() {\
  206|      2|    static BaseClass* d;\
  207|      2|    return d;\
  208|      2|  }\
_ZN9OpenBabel13OBFingerprintC2EPKcb:
  209|     18|  BaseClass(const char* ID, bool IsDefault=false) {\
  210|     18|    _id=ID;\
  211|     18|    if (ID&&*ID) {\
  ------------------
  |  Branch (211:9): [True: 18, False: 0]
  |  Branch (211:13): [True: 18, False: 0]
  ------------------
  212|     18|      if (IsDefault || Map().empty()) {\
  ------------------
  |  Branch (212:11): [True: 2, False: 16]
  |  Branch (212:24): [True: 0, False: 16]
  ------------------
  213|      2|        Default() = this;\
  214|      2|      }\
  215|     18|      if (Map().count(ID) == 0) {\
  ------------------
  |  Branch (215:11): [True: 18, False: 0]
  ------------------
  216|     18|        Map()[ID] = this;\
  217|     18|        PluginMap()[TypeID()] = this;\
  218|     18|      }\
  219|     18|    }\
  220|     18|  }\
_ZN9OpenBabel12OBForceField7DefaultEv:
  205|      6|  static BaseClass*& Default() {\
  206|      6|    static BaseClass* d;\
  207|      6|    return d;\
  208|      6|  }\
_ZN9OpenBabel12OBForceField3MapEv:
  197|     24|  static PluginMapType& Map() {\
  198|     24|    static PluginMapType m;\
  199|     24|    return m;\
  200|     24|  }\
_ZN9OpenBabel12OBForceFieldC2EPKcb:
  209|     10|  BaseClass(const char* ID, bool IsDefault=false) {\
  210|     10|    _id=ID;\
  211|     10|    if (ID&&*ID) {\
  ------------------
  |  Branch (211:9): [True: 10, False: 0]
  |  Branch (211:13): [True: 10, False: 0]
  ------------------
  212|     10|      if (IsDefault || Map().empty()) {\
  ------------------
  |  Branch (212:11): [True: 6, False: 4]
  |  Branch (212:24): [True: 0, False: 4]
  ------------------
  213|      6|        Default() = this;\
  214|      6|      }\
  215|     10|      if (Map().count(ID) == 0) {\
  ------------------
  |  Branch (215:11): [True: 10, False: 0]
  ------------------
  216|     10|        Map()[ID] = this;\
  217|     10|        PluginMap()[TypeID()] = this;\
  218|     10|      }\
  219|     10|    }\
  220|     10|  }\
_ZN9OpenBabel13OBChargeModel7DefaultEv:
  205|      2|  static BaseClass*& Default() {\
  206|      2|    static BaseClass* d;\
  207|      2|    return d;\
  208|      2|  }\
_ZN9OpenBabel13OBChargeModel3MapEv:
  197|     24|  static PluginMapType& Map() {\
  198|     24|    static PluginMapType m;\
  199|     24|    return m;\
  200|     24|  }\
_ZN9OpenBabel13OBChargeModelC2EPKcb:
  209|      8|  BaseClass(const char* ID, bool IsDefault=false) {\
  210|      8|    _id=ID;\
  211|      8|    if (ID&&*ID) {\
  ------------------
  |  Branch (211:9): [True: 8, False: 0]
  |  Branch (211:13): [True: 8, False: 0]
  ------------------
  212|      8|      if (IsDefault || Map().empty()) {\
  ------------------
  |  Branch (212:11): [True: 0, False: 8]
  |  Branch (212:24): [True: 2, False: 6]
  ------------------
  213|      2|        Default() = this;\
  214|      2|      }\
  215|      8|      if (Map().count(ID) == 0) {\
  ------------------
  |  Branch (215:11): [True: 8, False: 0]
  ------------------
  216|      8|        Map()[ID] = this;\
  217|      8|        PluginMap()[TypeID()] = this;\
  218|      8|      }\
  219|      8|    }\
  220|      8|  }\

_ZN9OpenBabel10OpGenAliasC2EPKc:
  398|      2|  OpGenAlias(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel6OBBase5ClearEv:
   79|      6|  {
   80|      6|    if (!_vdata.empty()) //clean up generic data
  ------------------
  |  Branch (80:9): [True: 0, False: 6]
  ------------------
   81|      0|      {
   82|      0|        OBDataIterator m;
   83|      0|        for (m = _vdata.begin();m != _vdata.end();++m)
  ------------------
  |  Branch (83:33): [True: 0, False: 0]
  ------------------
   84|      0|          delete *m;
   85|      0|        _vdata.clear();
   86|      0|      }
   87|       |
   88|      6|    return(true);
   89|      6|  }

_ZN9OpenBabel17GenerateByteCodesEPPNS_9_ByteCodeEiiii:
  505|  1.94k|  {
  506|  1.94k|    StackType neighbour[4];
  507|  1.94k|    StackType original;
  508|  1.94k|    int count,i,j;
  509|  1.94k|    ByteCode *ptr;
  510|  1.94k|    bool done,found;
  511|       |
  512|  1.94k|    if( curr != prev )
  ------------------
  |  Branch (512:9): [True: 1.88k, False: 54]
  ------------------
  513|  1.88k|      {
  514|  1.88k|        if( MonoAtom[curr].atomid < ATOMMINAMINO )
  ------------------
  |  |   62|  1.88k|#define ATOMMINAMINO   4
  ------------------
  |  Branch (514:13): [True: 6, False: 1.88k]
  ------------------
  515|      6|          {
  516|      6|            found = false;
  517|      6|            while( *node && ((*node)->type==BC_IDENT) )
  ------------------
  |  |  136|      4|#define BC_IDENT       0x05
  ------------------
  |  Branch (517:20): [True: 4, False: 2]
  |  Branch (517:29): [True: 0, False: 4]
  ------------------
  518|      0|              {
  519|      0|                if( (*node)->ident.value == MonoAtom[curr].atomid )
  ------------------
  |  Branch (519:21): [True: 0, False: 0]
  ------------------
  520|      0|                  {
  521|      0|                    node  = (ByteCode**)&(*node)->ident.tcond;
  522|      0|                    found = true;
  523|      0|                    break;
  524|      0|                  }
  525|      0|                else
  526|      0|                  node = (ByteCode**)&(*node)->ident.fcond;
  527|      0|              }
  528|       |
  529|      6|            if (!found)
  ------------------
  |  Branch (529:17): [True: 6, False: 0]
  ------------------
  530|      6|              {
  531|      6|                ptr = AllocateByteCode(BC_IDENT);
  ------------------
  |  |  136|      6|#define BC_IDENT       0x05
  ------------------
  532|      6|                ptr->ident.tcond = nullptr;
  533|      6|                ptr->ident.fcond = *node;
  534|      6|                *node = ptr;
  535|      6|                node = (ByteCode**)&ptr->ident.tcond;
  536|      6|                ptr->ident.value = MonoAtom[curr].atomid;
  537|      6|              }
  538|      6|            MonoBond[bond].index = BondIndex++;
  539|      6|            done = true;
  540|      6|          }
  541|  1.88k|        else if( MonoAtom[curr].index != -1 )
  ------------------
  |  Branch (541:18): [True: 716, False: 1.16k]
  ------------------
  542|    716|          {
  543|    716|            while( *node && ((*node)->type==BC_IDENT) )
  ------------------
  |  |  136|    108|#define BC_IDENT       0x05
  ------------------
  |  Branch (543:20): [True: 108, False: 608]
  |  Branch (543:29): [True: 0, False: 108]
  ------------------
  544|      0|              node = (ByteCode**)&(*node)->ident.fcond;
  545|       |
  546|    716|            found = false;
  547|    734|            while( *node && ((*node)->type==BC_LOCAL) )
  ------------------
  |  |  137|    116|#define BC_LOCAL       0x06
  ------------------
  |  Branch (547:20): [True: 116, False: 618]
  |  Branch (547:29): [True: 76, False: 40]
  ------------------
  548|     76|              {
  549|     76|                if( (*node)->local.value == MonoAtom[curr].index )
  ------------------
  |  Branch (549:21): [True: 58, False: 18]
  ------------------
  550|     58|                  {
  551|     58|                    node = (ByteCode**)&(*node)->local.tcond;
  552|     58|                    found = true;
  553|     58|                    break;
  554|     58|                  }
  555|     18|                else
  556|     18|                  node = (ByteCode**)&(*node)->local.fcond;
  557|     76|              }
  558|       |
  559|    716|            if (!found)
  ------------------
  |  Branch (559:17): [True: 658, False: 58]
  ------------------
  560|    658|              {
  561|    658|                ptr = AllocateByteCode(BC_LOCAL);
  ------------------
  |  |  137|    658|#define BC_LOCAL       0x06
  ------------------
  562|    658|                ptr->local.tcond = nullptr;
  563|    658|                ptr->local.fcond = *node;
  564|    658|                *node = ptr;
  565|    658|                node = (ByteCode**)&ptr->local.tcond;
  566|    658|                ptr->local.value = MonoAtom[curr].index;
  567|    658|              }
  568|       |
  569|    716|            MonoBond[bond].index = BondIndex++;
  570|    716|            done = true;
  571|    716|          }
  572|  1.16k|        else
  573|  1.16k|          {
  574|  1.17k|            while( *node && ((*node)->type==BC_IDENT) )
  ------------------
  |  |  136|    562|#define BC_IDENT       0x05
  ------------------
  |  Branch (574:20): [True: 562, False: 614]
  |  Branch (574:29): [True: 10, False: 552]
  ------------------
  575|     10|              node = (ByteCode**)&(*node)->ident.fcond;
  576|  1.21k|            while( *node && ((*node)->type==BC_LOCAL) )
  ------------------
  |  |  137|    580|#define BC_LOCAL       0x06
  ------------------
  |  Branch (576:20): [True: 580, False: 632]
  |  Branch (576:29): [True: 46, False: 534]
  ------------------
  577|     46|              node = (ByteCode**)&(*node)->local.fcond;
  578|       |
  579|  1.16k|            found = false;
  580|  1.38k|            while( *node && ((*node)->type==BC_ELEM) )
  ------------------
  |  |  134|    652|#define BC_ELEM        0x03
  ------------------
  |  Branch (580:20): [True: 652, False: 728]
  |  Branch (580:29): [True: 652, False: 0]
  ------------------
  581|    652|              {
  582|    652|                if( (*node)->elem.value == MonoAtom[curr].elem )
  ------------------
  |  Branch (582:21): [True: 438, False: 214]
  ------------------
  583|    438|                  {
  584|    438|                    node = (ByteCode**)&(*node)->elem.tcond;
  585|    438|                    found = true;
  586|    438|                    break;
  587|    438|                  }
  588|    214|                else
  589|    214|                  node = (ByteCode**)&(*node)->elem.fcond;
  590|    652|              }
  591|       |
  592|  1.16k|            if( !found )
  ------------------
  |  Branch (592:17): [True: 728, False: 438]
  ------------------
  593|    728|              {
  594|    728|                ptr = AllocateByteCode(BC_ELEM);
  ------------------
  |  |  134|    728|#define BC_ELEM        0x03
  ------------------
  595|    728|                ptr->elem.tcond = nullptr;
  596|    728|                ptr->elem.fcond = *node;
  597|    728|                *node = ptr;
  598|    728|                node = (ByteCode**)&ptr->elem.tcond;
  599|    728|                ptr->elem.value = MonoAtom[curr].elem;
  600|    728|              }
  601|       |
  602|  1.16k|            MonoAtom[curr].index = AtomIndex++;
  603|  1.16k|            MonoBond[bond].index = BondIndex++;
  604|  1.16k|            done = false;
  605|  1.16k|          }
  606|  1.88k|      }
  607|     54|    else
  608|     54|      {
  609|     54|        MonoAtom[curr].index = AtomIndex++;
  610|     54|        done = false;
  611|     54|      }
  612|       |
  613|  1.94k|    count = 0;
  614|  1.94k|    if (!done)
  ------------------
  |  Branch (614:9): [True: 1.22k, False: 722]
  ------------------
  615|  1.22k|      {
  616|  13.5k|        for( i=0; i<MonoBondCount; i++ )
  ------------------
  |  Branch (616:19): [True: 12.3k, False: 1.22k]
  ------------------
  617|  12.3k|          {
  618|  12.3k|            if( MonoBond[i].src == curr )
  ------------------
  |  Branch (618:17): [True: 1.00k, False: 11.3k]
  ------------------
  619|  1.00k|              {
  620|  1.00k|                if( MonoBond[i].dst != prev )
  ------------------
  |  Branch (620:21): [True: 656, False: 350]
  ------------------
  621|    656|                  {
  622|    656|                    neighbour[count].atom = MonoBond[i].dst;
  623|    656|                    neighbour[count].bond = i;
  624|    656|                    count++;
  625|    656|                  }
  626|  1.00k|              }
  627|  11.3k|            else if( MonoBond[i].dst == curr )
  ------------------
  |  Branch (627:22): [True: 1.22k, False: 10.1k]
  ------------------
  628|  1.22k|              {
  629|  1.22k|                if( MonoBond[i].src != prev )
  ------------------
  |  Branch (629:21): [True: 404, False: 816]
  ------------------
  630|    404|                  {
  631|    404|                    neighbour[count].atom = MonoBond[i].src;
  632|    404|                    neighbour[count].bond = i;
  633|    404|                    count++;
  634|    404|                  }
  635|  1.22k|              }
  636|  12.3k|          }
  637|       |
  638|  1.22k|        if ( *node && ((*node)->type==BC_EVAL) )
  ------------------
  |  |  135|    488|#define BC_EVAL        0x04
  ------------------
  |  Branch (638:14): [True: 488, False: 732]
  |  Branch (638:23): [True: 480, False: 8]
  ------------------
  639|    480|          {
  640|    480|            found = false;
  641|    480|            node  = (ByteCode**)&(*node)->eval.next;
  642|    674|            while( *node && ((*node)->type==BC_COUNT) )
  ------------------
  |  |  133|    584|#define BC_COUNT       0x02
  ------------------
  |  Branch (642:20): [True: 584, False: 90]
  |  Branch (642:29): [True: 584, False: 0]
  ------------------
  643|    584|              {
  644|    584|                if( (*node)->count.value == count )
  ------------------
  |  Branch (644:21): [True: 390, False: 194]
  ------------------
  645|    390|                  {
  646|    390|                    node = (ByteCode**)&(*node)->count.tcond;
  647|    390|                    found = true;
  648|    390|                    break;
  649|    390|                  }
  650|    194|                else
  651|    194|                  node = (ByteCode**)&(*node)->count.fcond;
  652|    584|              }
  653|       |
  654|    480|            if( !found )
  ------------------
  |  Branch (654:17): [True: 90, False: 390]
  ------------------
  655|     90|              {
  656|     90|                ptr = AllocateByteCode(BC_COUNT);
  ------------------
  |  |  133|     90|#define BC_COUNT       0x02
  ------------------
  657|     90|                ptr->count.tcond = nullptr;
  658|     90|                ptr->count.fcond = *node;
  659|     90|                *node = ptr;
  660|     90|                node = (ByteCode**)&ptr->count.tcond;
  661|     90|                ptr->count.value = count;
  662|     90|              }
  663|    480|          }
  664|    740|        else if( count || StrictFlag || StackPtr )
  ------------------
  |  Branch (664:18): [True: 436, False: 304]
  |  Branch (664:27): [True: 0, False: 304]
  |  Branch (664:41): [True: 262, False: 42]
  ------------------
  665|    698|          {
  666|    698|            ptr = AllocateByteCode(BC_EVAL);
  ------------------
  |  |  135|    698|#define BC_EVAL        0x04
  ------------------
  667|    698|            ptr->eval.next = *node;
  668|    698|            *node = ptr;
  669|    698|            node = (ByteCode**)&ptr->eval.next;
  670|       |
  671|    698|            ptr = AllocateByteCode(BC_COUNT);
  ------------------
  |  |  133|    698|#define BC_COUNT       0x02
  ------------------
  672|    698|            ptr->count.tcond = nullptr;
  673|    698|            ptr->count.fcond = *node;
  674|    698|            *node = ptr;
  675|    698|            node = (ByteCode**)&ptr->count.tcond;
  676|    698|            ptr->count.value = count;
  677|    698|          }
  678|  1.22k|      }
  679|       |
  680|  1.94k|    if( count == 1 )
  ------------------
  |  Branch (680:9): [True: 612, False: 1.33k]
  ------------------
  681|    612|      {
  682|    612|        GenerateByteCodes(node,resid,neighbour[0].atom, curr,neighbour[0].bond);
  683|    612|      }
  684|  1.33k|    else if( count == 2 )
  ------------------
  |  Branch (684:14): [True: 224, False: 1.10k]
  ------------------
  685|    224|      {
  686|    224|        original = Stack[StackPtr++];
  687|    224|        Stack[StackPtr-1] = neighbour[0];
  688|    224|        Stack[StackPtr-1].prev = curr;
  689|    224|        GenerateByteCodes(node,resid,neighbour[1].atom,
  690|    224|                          curr,neighbour[1].bond);
  691|    224|        Stack[StackPtr-1] = neighbour[1];
  692|    224|        Stack[StackPtr-1].prev = curr;
  693|    224|        GenerateByteCodes(node,resid,neighbour[0].atom,
  694|    224|                          curr,neighbour[0].bond);
  695|    224|        Stack[--StackPtr] = original;
  696|    224|      }
  697|  1.10k|    else if( count )
  ------------------
  |  Branch (697:14): [True: 0, False: 1.10k]
  ------------------
  698|      0|      {
  699|      0|        stringstream errorMsg;
  700|      0|        errorMsg << "Maximum Monomer Fanout Exceeded!" << endl;
  701|      0|        errorMsg << "Residue " << ChainsResName[resid] << " atom "
  702|      0|                 << curr << endl;
  703|      0|        errorMsg << "Previous = " << prev << " Fanout = " << count << endl;
  704|      0|        obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning);
  705|      0|      }
  706|  1.10k|    else if( StackPtr )
  ------------------
  |  Branch (706:14): [True: 828, False: 278]
  ------------------
  707|    828|      {
  708|    828|        StackPtr--;
  709|    828|        GenerateByteCodes(node,resid,Stack[StackPtr].atom,
  710|    828|                          Stack[StackPtr].prev,Stack[StackPtr].bond);
  711|    828|        StackPtr++;
  712|    828|      }
  713|    278|    else if( !(*node) )
  ------------------
  |  Branch (713:14): [True: 262, False: 16]
  ------------------
  714|    262|      {
  715|    262|        ptr = AllocateByteCode(BC_ASSIGN);
  ------------------
  |  |  132|    262|#define BC_ASSIGN      0x01
  ------------------
  716|    262|        ptr->assign.resid = resid;
  717|    262|        ptr->assign.atomid = new int[AtomIndex];
  718|    262|        if( !ptr->assign.atomid )
  ------------------
  |  Branch (718:13): [True: 0, False: 262]
  ------------------
  719|      0|          FatalMemoryError();
  720|  2.80k|        for( i=0; i<MonoAtomCount; i++ )
  ------------------
  |  Branch (720:19): [True: 2.54k, False: 262]
  ------------------
  721|  2.54k|          if( (j=MonoAtom[i].index) != -1 )
  ------------------
  |  Branch (721:15): [True: 2.54k, False: 6]
  ------------------
  722|  2.54k|            ptr->assign.atomid[j] = MonoAtom[i].atomid;
  723|    262|        if( BondIndex )
  ------------------
  |  Branch (723:13): [True: 260, False: 2]
  ------------------
  724|    260|          {
  725|    260|            ptr->assign.bflags = new int[BondIndex];
  726|  2.90k|            for( i=0; i<MonoBondCount; i++ )
  ------------------
  |  Branch (726:23): [True: 2.64k, False: 260]
  ------------------
  727|  2.64k|              if( (j=MonoBond[i].index) != -1 )
  ------------------
  |  Branch (727:19): [True: 2.64k, False: 0]
  ------------------
  728|  2.64k|                ptr->assign.bflags[j] = MonoBond[i].flag;
  729|    260|          }
  730|    262|        *node = ptr;
  731|    262|      }
  732|     16|    else if( (*node)->type == BC_ASSIGN )
  ------------------
  |  |  132|     16|#define BC_ASSIGN      0x01
  ------------------
  |  Branch (732:14): [True: 16, False: 0]
  ------------------
  733|     16|      {
  734|     16|        if( (*node)->assign.resid != resid )
  ------------------
  |  Branch (734:13): [True: 0, False: 16]
  ------------------
  735|      0|          {
  736|      0|            stringstream errorMsg;
  737|      0|            errorMsg << "Duplicated Monomer Specification!\n";
  738|      0|            errorMsg << "Residue " << ChainsResName[resid]
  739|      0|                     << " matches residue ";
  740|      0|            errorMsg << ChainsResName[(*node)->assign.resid] << endl;
  741|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning);
  742|      0|          }
  743|     16|      }
  744|       |
  745|       |    /* Restore State! */
  746|  1.94k|    if( curr != prev )
  ------------------
  |  Branch (746:9): [True: 1.88k, False: 54]
  ------------------
  747|  1.88k|      {
  748|  1.88k|        if( !done )
  ------------------
  |  Branch (748:13): [True: 1.16k, False: 722]
  ------------------
  749|  1.16k|          {
  750|  1.16k|            MonoAtom[curr].index = -1;
  751|  1.16k|            AtomIndex--;
  752|  1.16k|          }
  753|  1.88k|        MonoBond[bond].index = -1;
  754|  1.88k|        BondIndex--;
  755|  1.88k|      }
  756|  1.94k|  }
_ZN9OpenBabel14OBChainsParserC2Ev:
  764|      2|  {
  765|      2|    int i, res = RESIDMIN;
  ------------------
  |  |   49|      2|#define RESIDMIN       4
  ------------------
  766|       |
  767|      2|    PDecisionTree = (ByteCode*)nullptr;
  768|     44|    for( i=0 ; i < AMINOMAX ; i++ )
  ------------------
  |  |   69|     44|#define AMINOMAX       21
  ------------------
  |  Branch (768:16): [True: 42, False: 2]
  ------------------
  769|     42|      {
  770|     42|        strncpy(ChainsResName[res],AminoAcids[i].name, sizeof(ChainsResName[res]) - 1);
  771|     42|        ChainsResName[res][sizeof(ChainsResName[res]) - 1] = '\0';
  772|     42|        DefineMonomer(&PDecisionTree,res,AminoAcids[i].data);
  773|     42|        res++;
  774|     42|      }
  775|       |
  776|      2|    NDecisionTree = (ByteCode*)nullptr;
  777|     14|    for( i=0 ; i< NUCLEOMAX ; i++ )
  ------------------
  |  |   72|     14|#define NUCLEOMAX      6
  ------------------
  |  Branch (777:16): [True: 12, False: 2]
  ------------------
  778|     12|      {
  779|     12|        strncpy(ChainsResName[res],Nucleotides[i].name, sizeof(ChainsResName[res]) - 1);
  780|     12|        ChainsResName[res][sizeof(ChainsResName[res]) - 1] = '\0';
  781|     12|        DefineMonomer(&NDecisionTree,res,Nucleotides[i].data);
  782|     12|        res++;
  783|     12|      }
  784|      2|  }
_ZN9OpenBabel14OBChainsParser13DefineMonomerEPPviPKc:
 1870|     54|  {
 1871|     54|    int i;
 1872|       |
 1873|     54|    MonoAtomCount = 0;
 1874|     54|    MonoBondCount = 0;
 1875|       |
 1876|     54|    ParseSmiles(smiles,-1);
 1877|       |
 1878|    380|    for( i=0; i<MonoBondCount; i++ )
  ------------------
  |  Branch (1878:15): [True: 326, False: 54]
  ------------------
 1879|    326|      MonoBond[i].index = -1;
 1880|    406|    for( i=0; i<MonoAtomCount; i++ )
  ------------------
  |  Branch (1880:15): [True: 352, False: 54]
  ------------------
 1881|    352|      MonoAtom[i].index = -1;
 1882|     54|    AtomIndex = BondIndex = 0;
 1883|       |
 1884|     54|    StackPtr = 0;
 1885|     54|    GenerateByteCodes((ByteCode**)tree, resid, 0, 0, 0 );
 1886|     54|  }
_ZN9OpenBabel14OBChainsParser15IdentifyElementEPc:
 1889|    352|  {
 1890|    352|    int ch;
 1891|       |
 1892|    352|    ch = toupper(ptr[1]);
 1893|    352|    switch( toupper(ptr[0]) )
  ------------------
  |  Branch (1893:13): [True: 352, False: 0]
  ------------------
 1894|    352|      {
 1895|    352|      case(' '):  switch( ch )
  ------------------
  |  Branch (1895:7): [True: 352, False: 0]
  |  Branch (1895:27): [True: 352, False: 0]
  ------------------
 1896|    352|          {
 1897|      0|          case('B'):  return(  5 );
  ------------------
  |  Branch (1897:11): [True: 0, False: 352]
  ------------------
 1898|    250|          case('C'):  return(  6 );
  ------------------
  |  Branch (1898:11): [True: 250, False: 102]
  ------------------
 1899|      0|          case('D'):  return(  1 );
  ------------------
  |  Branch (1899:11): [True: 0, False: 352]
  ------------------
 1900|      0|          case('F'):  return(  9 );
  ------------------
  |  Branch (1900:11): [True: 0, False: 352]
  ------------------
 1901|      0|          case('H'):  return(  1 );
  ------------------
  |  Branch (1901:11): [True: 0, False: 352]
  ------------------
 1902|      0|          case('I'):  return( 53 );
  ------------------
  |  Branch (1902:11): [True: 0, False: 352]
  ------------------
 1903|      0|          case('K'):  return( 19 );
  ------------------
  |  Branch (1903:11): [True: 0, False: 352]
  ------------------
 1904|      0|          case('L'):  return(  1 );
  ------------------
  |  Branch (1904:11): [True: 0, False: 352]
  ------------------
 1905|     64|          case('N'):  return(  7 );
  ------------------
  |  Branch (1905:11): [True: 64, False: 288]
  ------------------
 1906|     34|          case('O'):  return(  8 );
  ------------------
  |  Branch (1906:11): [True: 34, False: 318]
  ------------------
 1907|      0|          case('P'):  return( 15 );
  ------------------
  |  Branch (1907:11): [True: 0, False: 352]
  ------------------
 1908|      4|          case('S'):  return( 16 );
  ------------------
  |  Branch (1908:11): [True: 4, False: 348]
  ------------------
 1909|      0|          case('U'):  return( 92 );
  ------------------
  |  Branch (1909:11): [True: 0, False: 352]
  ------------------
 1910|      0|          case('V'):  return( 23 );
  ------------------
  |  Branch (1910:11): [True: 0, False: 352]
  ------------------
 1911|      0|          case('W'):  return( 74 );
  ------------------
  |  Branch (1911:11): [True: 0, False: 352]
  ------------------
 1912|      0|          case('Y'):  return( 39 );
  ------------------
  |  Branch (1912:11): [True: 0, False: 352]
  ------------------
 1913|    352|          }
 1914|      0|        break;
 1915|       |
 1916|      0|      case('A'):  switch( ch )
  ------------------
  |  Branch (1916:7): [True: 0, False: 352]
  |  Branch (1916:27): [True: 0, False: 0]
  ------------------
 1917|      0|          {
 1918|      0|          case('C'):  return( 89 );
  ------------------
  |  Branch (1918:11): [True: 0, False: 0]
  ------------------
 1919|      0|          case('G'):  return( 47 );
  ------------------
  |  Branch (1919:11): [True: 0, False: 0]
  ------------------
 1920|      0|          case('L'):  return( 13 );
  ------------------
  |  Branch (1920:11): [True: 0, False: 0]
  ------------------
 1921|      0|          case('M'):  return( 95 );
  ------------------
  |  Branch (1921:11): [True: 0, False: 0]
  ------------------
 1922|      0|          case('R'):  return( 18 );
  ------------------
  |  Branch (1922:11): [True: 0, False: 0]
  ------------------
 1923|      0|          case('S'):  return( 33 );
  ------------------
  |  Branch (1923:11): [True: 0, False: 0]
  ------------------
 1924|      0|          case('T'):  return( 85 );
  ------------------
  |  Branch (1924:11): [True: 0, False: 0]
  ------------------
 1925|      0|          case('U'):  return( 79 );
  ------------------
  |  Branch (1925:11): [True: 0, False: 0]
  ------------------
 1926|      0|          }
 1927|      0|        break;
 1928|       |
 1929|      0|      case('B'):  switch( ch )
  ------------------
  |  Branch (1929:7): [True: 0, False: 352]
  |  Branch (1929:27): [True: 0, False: 0]
  ------------------
 1930|      0|          {
 1931|      0|          case('A'):  return( 56 );
  ------------------
  |  Branch (1931:11): [True: 0, False: 0]
  ------------------
 1932|      0|          case('E'):  return(  4 );
  ------------------
  |  Branch (1932:11): [True: 0, False: 0]
  ------------------
 1933|      0|          case('I'):  return( 83 );
  ------------------
  |  Branch (1933:11): [True: 0, False: 0]
  ------------------
 1934|      0|          case('K'):  return( 97 );
  ------------------
  |  Branch (1934:11): [True: 0, False: 0]
  ------------------
 1935|      0|          case('R'):  return( 35 );
  ------------------
  |  Branch (1935:11): [True: 0, False: 0]
  ------------------
 1936|      0|          case(' '):  return(  5 );
  ------------------
  |  Branch (1936:11): [True: 0, False: 0]
  ------------------
 1937|      0|          }
 1938|      0|        break;
 1939|       |
 1940|      0|      case('C'):  switch( ch )
  ------------------
  |  Branch (1940:7): [True: 0, False: 352]
  |  Branch (1940:27): [True: 0, False: 0]
  ------------------
 1941|      0|          {
 1942|      0|          case('A'):  return( 20 );
  ------------------
  |  Branch (1942:11): [True: 0, False: 0]
  ------------------
 1943|      0|          case('D'):  return( 48 );
  ------------------
  |  Branch (1943:11): [True: 0, False: 0]
  ------------------
 1944|      0|          case('E'):  return( 58 );
  ------------------
  |  Branch (1944:11): [True: 0, False: 0]
  ------------------
 1945|      0|          case('F'):  return( 98 );
  ------------------
  |  Branch (1945:11): [True: 0, False: 0]
  ------------------
 1946|      0|          case('L'):  return( 17 );
  ------------------
  |  Branch (1946:11): [True: 0, False: 0]
  ------------------
 1947|      0|          case('M'):  return( 96 );
  ------------------
  |  Branch (1947:11): [True: 0, False: 0]
  ------------------
 1948|      0|          case('O'):  return( 27 );
  ------------------
  |  Branch (1948:11): [True: 0, False: 0]
  ------------------
 1949|      0|          case('R'):  return( 24 );
  ------------------
  |  Branch (1949:11): [True: 0, False: 0]
  ------------------
 1950|      0|          case('S'):  return( 55 );
  ------------------
  |  Branch (1950:11): [True: 0, False: 0]
  ------------------
 1951|      0|          case('U'):  return( 29 );
  ------------------
  |  Branch (1951:11): [True: 0, False: 0]
  ------------------
 1952|      0|          case(' '):  return(  6 );
  ------------------
  |  Branch (1952:11): [True: 0, False: 0]
  ------------------
 1953|      0|          }
 1954|      0|        break;
 1955|       |
 1956|      0|      case('D'):  if( ch=='Y' )
  ------------------
  |  Branch (1956:7): [True: 0, False: 352]
  |  Branch (1956:23): [True: 0, False: 0]
  ------------------
 1957|      0|          {
 1958|      0|            return( 66 );
 1959|      0|          }
 1960|      0|        else if( ch==' ' )
  ------------------
  |  Branch (1960:18): [True: 0, False: 0]
  ------------------
 1961|      0|          return( 1 );
 1962|      0|        break;
 1963|       |
 1964|      0|      case('E'):  if( ch=='R' )
  ------------------
  |  Branch (1964:7): [True: 0, False: 352]
  |  Branch (1964:23): [True: 0, False: 0]
  ------------------
 1965|      0|          {
 1966|      0|            return( 68 );
 1967|      0|          }
 1968|      0|        else if( ch=='S' )
  ------------------
  |  Branch (1968:18): [True: 0, False: 0]
  ------------------
 1969|      0|          {
 1970|      0|            return( 99 );
 1971|      0|          }
 1972|      0|        else if( ch=='U' )
  ------------------
  |  Branch (1972:18): [True: 0, False: 0]
  ------------------
 1973|      0|          return( 63 );
 1974|      0|        break;
 1975|       |
 1976|      0|      case('F'):  if( ch=='E' )
  ------------------
  |  Branch (1976:7): [True: 0, False: 352]
  |  Branch (1976:23): [True: 0, False: 0]
  ------------------
 1977|      0|          {
 1978|      0|            return(  26 );
 1979|      0|          }
 1980|      0|        else if( ch=='M' )
  ------------------
  |  Branch (1980:18): [True: 0, False: 0]
  ------------------
 1981|      0|          {
 1982|      0|            return( 100 );
 1983|      0|          }
 1984|      0|        else if( ch=='R' )
  ------------------
  |  Branch (1984:18): [True: 0, False: 0]
  ------------------
 1985|      0|          {
 1986|      0|            return(  87 );
 1987|      0|          }
 1988|      0|        else if( ch=='F' )
  ------------------
  |  Branch (1988:18): [True: 0, False: 0]
  ------------------
 1989|      0|          return(   9 );
 1990|      0|        break;
 1991|       |
 1992|      0|      case('G'):  if( ch=='A' )
  ------------------
  |  Branch (1992:7): [True: 0, False: 352]
  |  Branch (1992:23): [True: 0, False: 0]
  ------------------
 1993|      0|          {
 1994|      0|            return( 31 );
 1995|      0|          }
 1996|      0|        else if( ch=='D' )
  ------------------
  |  Branch (1996:18): [True: 0, False: 0]
  ------------------
 1997|      0|          {
 1998|      0|            return( 64 );
 1999|      0|          }
 2000|      0|        else if( ch=='E' )
  ------------------
  |  Branch (2000:18): [True: 0, False: 0]
  ------------------
 2001|      0|          return( 32 );
 2002|      0|        break;
 2003|       |
 2004|      0|      case('H'):  if( ch=='E' )
  ------------------
  |  Branch (2004:7): [True: 0, False: 352]
  |  Branch (2004:23): [True: 0, False: 0]
  ------------------
 2005|      0|          {
 2006|      0|            return(  2 );
 2007|      0|          }
 2008|      0|        else if( ch=='F' )
  ------------------
  |  Branch (2008:18): [True: 0, False: 0]
  ------------------
 2009|      0|          {
 2010|      0|            return( 72 );
 2011|      0|          }
 2012|      0|        else if( ch=='G' )
  ------------------
  |  Branch (2012:18): [True: 0, False: 0]
  ------------------
 2013|      0|          {
 2014|      0|            return( 80 );
 2015|      0|          }
 2016|      0|        else if( ch=='O' )
  ------------------
  |  Branch (2016:18): [True: 0, False: 0]
  ------------------
 2017|      0|          {
 2018|      0|            return( 67 );
 2019|      0|          }
 2020|      0|        else if( ch==' ' )
  ------------------
  |  Branch (2020:18): [True: 0, False: 0]
  ------------------
 2021|      0|          return(  1 );
 2022|      0|        break;
 2023|       |
 2024|      0|      case('I'):  if( ch=='N' )
  ------------------
  |  Branch (2024:7): [True: 0, False: 352]
  |  Branch (2024:23): [True: 0, False: 0]
  ------------------
 2025|      0|          {
 2026|      0|            return( 49 );
 2027|      0|          }
 2028|      0|        else if( ch=='R' )
  ------------------
  |  Branch (2028:18): [True: 0, False: 0]
  ------------------
 2029|      0|          {
 2030|      0|            return( 77 );
 2031|      0|          }
 2032|      0|        else if( ch==' ' )
  ------------------
  |  Branch (2032:18): [True: 0, False: 0]
  ------------------
 2033|      0|          return( 53 );
 2034|      0|        break;
 2035|       |
 2036|      0|      case('K'):  if( ch=='R' )
  ------------------
  |  Branch (2036:7): [True: 0, False: 352]
  |  Branch (2036:23): [True: 0, False: 0]
  ------------------
 2037|      0|          {
 2038|      0|            return( 36 );
 2039|      0|          }
 2040|      0|        else if( ch==' ' )
  ------------------
  |  Branch (2040:18): [True: 0, False: 0]
  ------------------
 2041|      0|          return( 19 );
 2042|      0|        break;
 2043|       |
 2044|      0|      case('L'):  if( ch=='A' )
  ------------------
  |  Branch (2044:7): [True: 0, False: 352]
  |  Branch (2044:23): [True: 0, False: 0]
  ------------------
 2045|      0|          {
 2046|      0|            return(  57 );
 2047|      0|          }
 2048|      0|        else if( ch=='I' )
  ------------------
  |  Branch (2048:18): [True: 0, False: 0]
  ------------------
 2049|      0|          {
 2050|      0|            return(   3 );
 2051|      0|          }
 2052|      0|        else if( (ch=='R') || (ch=='W') )
  ------------------
  |  Branch (2052:18): [True: 0, False: 0]
  |  Branch (2052:31): [True: 0, False: 0]
  ------------------
 2053|      0|          {
 2054|      0|            return( 103 );
 2055|      0|          }
 2056|      0|        else if( ch=='U' )
  ------------------
  |  Branch (2056:18): [True: 0, False: 0]
  ------------------
 2057|      0|          {
 2058|      0|            return(  71 );
 2059|      0|          }
 2060|      0|        else if( ch==' ' )
  ------------------
  |  Branch (2060:18): [True: 0, False: 0]
  ------------------
 2061|      0|          return(   1 );
 2062|      0|        break;
 2063|       |
 2064|      0|      case('M'):  if( ch=='D' )
  ------------------
  |  Branch (2064:7): [True: 0, False: 352]
  |  Branch (2064:23): [True: 0, False: 0]
  ------------------
 2065|      0|          {
 2066|      0|            return( 101 );
 2067|      0|          }
 2068|      0|        else if( ch=='G' )
  ------------------
  |  Branch (2068:18): [True: 0, False: 0]
  ------------------
 2069|      0|          {
 2070|      0|            return(  12 );
 2071|      0|          }
 2072|      0|        else if( ch=='N' )
  ------------------
  |  Branch (2072:18): [True: 0, False: 0]
  ------------------
 2073|      0|          {
 2074|      0|            return(  25 );
 2075|      0|          }
 2076|      0|        else if( ch=='O' )
  ------------------
  |  Branch (2076:18): [True: 0, False: 0]
  ------------------
 2077|      0|          return(  42 );
 2078|      0|        break;
 2079|       |
 2080|      0|      case('N'):  switch( ch )
  ------------------
  |  Branch (2080:7): [True: 0, False: 352]
  |  Branch (2080:27): [True: 0, False: 0]
  ------------------
 2081|      0|          {
 2082|      0|          case('A'):  return(  11 );
  ------------------
  |  Branch (2082:11): [True: 0, False: 0]
  ------------------
 2083|      0|          case('B'):  return(  41 );
  ------------------
  |  Branch (2083:11): [True: 0, False: 0]
  ------------------
 2084|      0|          case('D'):  return(  60 );
  ------------------
  |  Branch (2084:11): [True: 0, False: 0]
  ------------------
 2085|      0|          case('E'):  return(  10 );
  ------------------
  |  Branch (2085:11): [True: 0, False: 0]
  ------------------
 2086|      0|          case('I'):  return(  28 );
  ------------------
  |  Branch (2086:11): [True: 0, False: 0]
  ------------------
 2087|      0|          case('O'):  return( 102 );
  ------------------
  |  Branch (2087:11): [True: 0, False: 0]
  ------------------
 2088|      0|          case('P'):  return(  93 );
  ------------------
  |  Branch (2088:11): [True: 0, False: 0]
  ------------------
 2089|      0|          case(' '):  return(   7 );
  ------------------
  |  Branch (2089:11): [True: 0, False: 0]
  ------------------
 2090|      0|          }
 2091|      0|        break;
 2092|       |
 2093|      0|      case('O'):  if( ch=='S' )
  ------------------
  |  Branch (2093:7): [True: 0, False: 352]
  |  Branch (2093:23): [True: 0, False: 0]
  ------------------
 2094|      0|          {
 2095|      0|            return( 76 );
 2096|      0|          }
 2097|      0|        else if( ch==' ' )
  ------------------
  |  Branch (2097:18): [True: 0, False: 0]
  ------------------
 2098|      0|          return( 8 );
 2099|      0|        break;
 2100|       |
 2101|      0|      case('P'):  switch( ch )
  ------------------
  |  Branch (2101:7): [True: 0, False: 352]
  |  Branch (2101:27): [True: 0, False: 0]
  ------------------
 2102|      0|          {
 2103|      0|          case('A'):  return( 91 );
  ------------------
  |  Branch (2103:11): [True: 0, False: 0]
  ------------------
 2104|      0|          case('B'):  return( 82 );
  ------------------
  |  Branch (2104:11): [True: 0, False: 0]
  ------------------
 2105|      0|          case('D'):  return( 46 );
  ------------------
  |  Branch (2105:11): [True: 0, False: 0]
  ------------------
 2106|      0|          case('M'):  return( 61 );
  ------------------
  |  Branch (2106:11): [True: 0, False: 0]
  ------------------
 2107|      0|          case('O'):  return( 84 );
  ------------------
  |  Branch (2107:11): [True: 0, False: 0]
  ------------------
 2108|      0|          case('R'):  return( 59 );
  ------------------
  |  Branch (2108:11): [True: 0, False: 0]
  ------------------
 2109|      0|          case('T'):  return( 78 );
  ------------------
  |  Branch (2109:11): [True: 0, False: 0]
  ------------------
 2110|      0|          case('U'):  return( 94 );
  ------------------
  |  Branch (2110:11): [True: 0, False: 0]
  ------------------
 2111|      0|          case(' '):  return( 15 );
  ------------------
  |  Branch (2111:11): [True: 0, False: 0]
  ------------------
 2112|      0|          }
 2113|      0|        break;
 2114|       |
 2115|      0|      case('R'):  switch( ch )
  ------------------
  |  Branch (2115:7): [True: 0, False: 352]
  |  Branch (2115:27): [True: 0, False: 0]
  ------------------
 2116|      0|          {
 2117|      0|          case('A'):  return( 88 );
  ------------------
  |  Branch (2117:11): [True: 0, False: 0]
  ------------------
 2118|      0|          case('B'):  return( 37 );
  ------------------
  |  Branch (2118:11): [True: 0, False: 0]
  ------------------
 2119|      0|          case('E'):  return( 75 );
  ------------------
  |  Branch (2119:11): [True: 0, False: 0]
  ------------------
 2120|      0|          case('H'):  return( 45 );
  ------------------
  |  Branch (2120:11): [True: 0, False: 0]
  ------------------
 2121|      0|          case('N'):  return( 86 );
  ------------------
  |  Branch (2121:11): [True: 0, False: 0]
  ------------------
 2122|      0|          case('U'):  return( 44 );
  ------------------
  |  Branch (2122:11): [True: 0, False: 0]
  ------------------
 2123|      0|          }
 2124|      0|        break;
 2125|       |
 2126|      0|      case('S'):  switch( ch )
  ------------------
  |  Branch (2126:7): [True: 0, False: 352]
  |  Branch (2126:27): [True: 0, False: 0]
  ------------------
 2127|      0|          {
 2128|      0|          case('B'):  return( 51 );
  ------------------
  |  Branch (2128:11): [True: 0, False: 0]
  ------------------
 2129|      0|          case('C'):  return( 21 );
  ------------------
  |  Branch (2129:11): [True: 0, False: 0]
  ------------------
 2130|      0|          case('E'):  return( 34 );
  ------------------
  |  Branch (2130:11): [True: 0, False: 0]
  ------------------
 2131|      0|          case('I'):  return( 14 );
  ------------------
  |  Branch (2131:11): [True: 0, False: 0]
  ------------------
 2132|      0|          case('M'):  return( 62 );
  ------------------
  |  Branch (2132:11): [True: 0, False: 0]
  ------------------
 2133|      0|          case('N'):  return( 50 );
  ------------------
  |  Branch (2133:11): [True: 0, False: 0]
  ------------------
 2134|      0|          case('R'):  return( 38 );
  ------------------
  |  Branch (2134:11): [True: 0, False: 0]
  ------------------
 2135|      0|          case(' '):  return( 16 );
  ------------------
  |  Branch (2135:11): [True: 0, False: 0]
  ------------------
 2136|      0|          }
 2137|      0|        break;
 2138|       |
 2139|      0|      case('T'):  switch( ch )
  ------------------
  |  Branch (2139:7): [True: 0, False: 352]
  |  Branch (2139:27): [True: 0, False: 0]
  ------------------
 2140|      0|          {
 2141|      0|          case('A'):  return( 73 );
  ------------------
  |  Branch (2141:11): [True: 0, False: 0]
  ------------------
 2142|      0|          case('B'):  return( 65 );
  ------------------
  |  Branch (2142:11): [True: 0, False: 0]
  ------------------
 2143|      0|          case('C'):  return( 43 );
  ------------------
  |  Branch (2143:11): [True: 0, False: 0]
  ------------------
 2144|      0|          case('E'):  return( 52 );
  ------------------
  |  Branch (2144:11): [True: 0, False: 0]
  ------------------
 2145|      0|          case('H'):  return( 90 );
  ------------------
  |  Branch (2145:11): [True: 0, False: 0]
  ------------------
 2146|      0|          case('I'):  return( 22 );
  ------------------
  |  Branch (2146:11): [True: 0, False: 0]
  ------------------
 2147|      0|          case('L'):  return( 81 );
  ------------------
  |  Branch (2147:11): [True: 0, False: 0]
  ------------------
 2148|      0|          case('M'):  return( 69 );
  ------------------
  |  Branch (2148:11): [True: 0, False: 0]
  ------------------
 2149|      0|          }
 2150|      0|        break;
 2151|       |
 2152|      0|      case('U'):  if( ch==' ' )
  ------------------
  |  Branch (2152:7): [True: 0, False: 352]
  |  Branch (2152:23): [True: 0, False: 0]
  ------------------
 2153|      0|          return( 92 );
 2154|      0|        break;
 2155|       |
 2156|      0|      case('V'):  if( ch==' ' )
  ------------------
  |  Branch (2156:7): [True: 0, False: 352]
  |  Branch (2156:23): [True: 0, False: 0]
  ------------------
 2157|      0|          return( 23 );
 2158|      0|        break;
 2159|       |
 2160|      0|      case('W'):  if( ch==' ' )
  ------------------
  |  Branch (2160:7): [True: 0, False: 352]
  |  Branch (2160:23): [True: 0, False: 0]
  ------------------
 2161|      0|          return( 74 );
 2162|      0|        break;
 2163|       |
 2164|      0|      case('X'):  if( ch=='E' )
  ------------------
  |  Branch (2164:7): [True: 0, False: 352]
  |  Branch (2164:23): [True: 0, False: 0]
  ------------------
 2165|      0|          return( 54 );
 2166|      0|        break;
 2167|       |
 2168|      0|      case('Y'):  if( ch=='B' )
  ------------------
  |  Branch (2168:7): [True: 0, False: 352]
  |  Branch (2168:23): [True: 0, False: 0]
  ------------------
 2169|      0|          {
 2170|      0|            return( 70 );
 2171|      0|          }
 2172|      0|        else if( ch==' ' )
  ------------------
  |  Branch (2172:18): [True: 0, False: 0]
  ------------------
 2173|      0|          return( 39 );
 2174|      0|        break;
 2175|       |
 2176|      0|      case('Z'):  if( ch=='N' )
  ------------------
  |  Branch (2176:7): [True: 0, False: 352]
  |  Branch (2176:23): [True: 0, False: 0]
  ------------------
 2177|      0|          {
 2178|      0|            return( 30 );
 2179|      0|          }
 2180|      0|        else if( ch=='R' )
  ------------------
  |  Branch (2180:18): [True: 0, False: 0]
  ------------------
 2181|      0|          return( 40 );
 2182|      0|        break;
 2183|    352|      }
 2184|       |
 2185|      0|    if( (*ptr>='0') && (*ptr<='9') )
  ------------------
  |  Branch (2185:9): [True: 0, False: 0]
  |  Branch (2185:24): [True: 0, False: 0]
  ------------------
 2186|      0|      if( (ch=='H') || (ch=='D') )
  ------------------
  |  Branch (2186:11): [True: 0, False: 0]
  |  Branch (2186:24): [True: 0, False: 0]
  ------------------
 2187|      0|        return( 1 ); /* Hydrogen */
 2188|       |
 2189|      0|    return( 0 );
 2190|      0|  }
_ZN9OpenBabel14OBChainsParser11ParseSmilesEPKci:
 2193|    106|  {
 2194|    106|    char *name;
 2195|    106|    int atomid;
 2196|    106|    int next;
 2197|    106|    int type;
 2198|    106|    int ch;
 2199|       |
 2200|    106|    type = 0;
 2201|    864|    while( (ch = *ptr++) )
  ------------------
  |  Branch (2201:12): [True: 810, False: 54]
  ------------------
 2202|    810|      {
 2203|    810|        switch( ch )
 2204|    810|          {
 2205|    262|          case('-'): type = BF_SINGLE;
  ------------------
  |  |  139|    262|#define BF_SINGLE      0x01
  ------------------
  |  Branch (2205:11): [True: 262, False: 548]
  ------------------
 2206|    262|            break;
 2207|     10|          case('='): type = BF_DOUBLE;
  ------------------
  |  |  140|     10|#define BF_DOUBLE      0x02
  ------------------
  |  Branch (2207:11): [True: 10, False: 800]
  ------------------
 2208|     10|            break;
 2209|      0|          case('#'): type = BF_TRIPLE;
  ------------------
  |  |  141|      0|#define BF_TRIPLE      0x04
  ------------------
  |  Branch (2209:11): [True: 0, False: 810]
  ------------------
 2210|      0|            break;
 2211|     30|          case('^'): type = BF_SINGLE|BF_AROMATIC;
  ------------------
  |  |  139|     30|#define BF_SINGLE      0x01
  ------------------
                        case('^'): type = BF_SINGLE|BF_AROMATIC;
  ------------------
  |  |  142|     30|#define BF_AROMATIC    0x08
  ------------------
  |  Branch (2211:11): [True: 30, False: 780]
  ------------------
 2212|     30|            break;
 2213|     24|          case('~'): type = BF_DOUBLE|BF_AROMATIC;
  ------------------
  |  |  140|     24|#define BF_DOUBLE      0x02
  ------------------
                        case('~'): type = BF_DOUBLE|BF_AROMATIC;
  ------------------
  |  |  142|     24|#define BF_AROMATIC    0x08
  ------------------
  |  Branch (2213:11): [True: 24, False: 786]
  ------------------
 2214|     24|            break;
 2215|       |
 2216|     52|          case(')'): return( ptr );
  ------------------
  |  Branch (2216:11): [True: 52, False: 758]
  ------------------
 2217|      0|          case('.'): prev = -1;
  ------------------
  |  Branch (2217:11): [True: 0, False: 810]
  ------------------
 2218|      0|            break;
 2219|     52|          case('('): ptr = ParseSmiles(ptr,prev);
  ------------------
  |  Branch (2219:11): [True: 52, False: 758]
  ------------------
 2220|     52|            break;
 2221|       |
 2222|    380|          default:
  ------------------
  |  Branch (2222:11): [True: 380, False: 430]
  ------------------
 2223|    380|            atomid = ch-'0';
 2224|    628|            while( isdigit(*ptr) )
  ------------------
  |  Branch (2224:20): [True: 248, False: 380]
  ------------------
 2225|    248|              atomid = (atomid*10)+(*ptr++)-'0';
 2226|       |
 2227|  1.64k|            for( next=0; next<MonoAtomCount; next++ )
  ------------------
  |  Branch (2227:26): [True: 1.29k, False: 352]
  ------------------
 2228|  1.29k|              if( MonoAtom[next].atomid == atomid )
  ------------------
  |  Branch (2228:19): [True: 28, False: 1.26k]
  ------------------
 2229|     28|                break;
 2230|       |
 2231|    380|            if( next == MonoAtomCount )
  ------------------
  |  Branch (2231:17): [True: 352, False: 28]
  ------------------
 2232|    352|              {
 2233|    352|                name = ChainsAtomName[atomid];
 2234|    352|                MonoAtom[next].elem = IdentifyElement(name);
 2235|    352|                MonoAtom[next].atomid = atomid;
 2236|    352|                MonoAtom[next].bcount = 0;
 2237|    352|                MonoAtomCount++;
 2238|    352|              }
 2239|       |
 2240|    380|            if( prev != -1 )
  ------------------
  |  Branch (2240:17): [True: 326, False: 54]
  ------------------
 2241|    326|              {
 2242|    326|                MonoBond[MonoBondCount].flag = type;
 2243|    326|                MonoBond[MonoBondCount].src = prev;
 2244|    326|                MonoBond[MonoBondCount].dst = next;
 2245|    326|                MonoBondCount++;
 2246|       |
 2247|    326|                MonoAtom[prev].bcount++;
 2248|    326|                MonoAtom[next].bcount++;
 2249|    326|              }
 2250|    380|            prev = next;
 2251|    810|          }
 2252|    810|      }
 2253|     54|    return( ptr-1 );
 2254|    106|  }
chains.cpp:_ZN9OpenBabelL16AllocateByteCodeEi:
  418|  3.14k|  {
  419|  3.14k|    ByteCode *result;
  420|       |
  421|  3.14k|    result = new ByteCode;
  422|  3.14k|    if( !result )
  ------------------
  |  Branch (422:9): [True: 0, False: 3.14k]
  ------------------
  423|      0|      {
  424|      0|        obErrorLog.ThrowError(__FUNCTION__, "Unable to allocate byte codes for biomolecule residue perception.", obError);
  425|      0|        return (result);
  426|      0|      }
  427|  3.14k|    result->type = type;
  428|  3.14k|    result->eval.next     = nullptr;
  429|  3.14k|    result->count.tcond   = nullptr;
  430|  3.14k|    result->count.fcond   = nullptr;
  431|  3.14k|    result->elem.tcond    = nullptr;
  432|  3.14k|    result->elem.fcond    = nullptr;
  433|  3.14k|    result->ident.tcond   = nullptr;
  434|  3.14k|    result->ident.fcond   = nullptr;
  435|  3.14k|    result->local.tcond   = nullptr;
  436|  3.14k|    result->local.fcond   = nullptr;
  437|  3.14k|    result->assign.atomid = nullptr;
  438|  3.14k|    result->assign.bflags = nullptr;
  439|       |
  440|  3.14k|    return (result);
  441|  3.14k|  }

_ZN9OpenBabel15FromFileChargesC2EPKc:
   45|      2|			FromFileCharges(const char* ID) : OBChargeModel(ID, false){
   46|      2|			};

_ZN9OpenBabel16GasteigerChargesC2EPKc:
   30|      2|  GasteigerCharges(const char* ID) : OBChargeModel(ID, false){};

_ZN9OpenBabel13MMFF94ChargesC2EPKc:
   34|      2|  MMFF94Charges(const char* ID) : OBChargeModel(ID, false){};

_ZN9OpenBabel9NoChargesC2EPKc:
   32|      2|  NoCharges(const char* ID) : OBChargeModel(ID, false){};

_ZN9OpenBabel11OBTypeTableC2Ev:
  248|      2|  {
  249|      2|    _init = false;
  250|      2|    _dir = BABEL_DATADIR;
  ------------------
  |  |    4|      2|#define BABEL_DATADIR "/usr/local/share/openbabel"
  ------------------
  251|      2|    _envvar = "BABEL_DATADIR";
  252|      2|    _filename = "types.txt";
  253|      2|    _subdir = "data";
  254|      2|    _dataptr = TypesData;
  255|      2|    _linecount = 0;
  256|      2|    _from = _to = -1;
  257|      2|  }
_ZN9OpenBabel13OBResidueDataC2Ev:
  433|      2|  {
  434|      2|    _init = false;
  435|      2|    _dir = BABEL_DATADIR;
  ------------------
  |  |    4|      2|#define BABEL_DATADIR "/usr/local/share/openbabel"
  ------------------
  436|      2|    _envvar = "BABEL_DATADIR";
  437|      2|    _filename = "resdata.txt";
  438|      2|    _subdir = "data";
  439|      2|    _dataptr = ResidueData;
  440|      2|  }

_ZN9OpenBabel9CanSmilesC2EPKcb:
   31|      4|  CanSmiles(const char* ID, bool noStereo) : OBDescriptor(ID), _noStereo(noStereo){};

_ZN9OpenBabel14CompoundFilterC2EPKcS2_S2_:
   55|      2|    : OBDescriptor(ID), _descr(descr), _macroText(macrotext){}

_ZN9OpenBabel8MWFilterC2EPKc:
   33|      2|  MWFilter(const char *ID) : OBDescriptor(ID){};
_ZN9OpenBabel20RotatableBondsFilterC2EPKc:
   47|      2|  RotatableBondsFilter(const char *ID) : OBDescriptor(ID){};
_ZN9OpenBabel12SmartsFilterC2EPKc:
   64|      4|  SmartsFilter(const char *ID) : OBDescriptor(ID){};
_ZN9OpenBabel11TitleFilterC2EPKc:
  107|      2|  TitleFilter(const char *ID) : OBDescriptor(ID){};
_ZN9OpenBabel17FormulaDescriptorC2EPKc:
  151|      2|  FormulaDescriptor(const char *ID) : OBDescriptor(ID){};

_ZN9OpenBabel11InChIFilterC2EPKcb:
   33|      4|  InChIFilter(const char* ID, bool useKey=false) : OBDescriptor(ID), bKey(useKey) {};

_ZN9OpenBabel16SmartsDescriptorC2EPKcS2_S2_:
   35|      8|      : OBDescriptor(ID, false), _smarts(smarts), _descr(descr){}

_ZN9OpenBabel12fingerprint2C2EPKcb:
   38|      2|		: OBFingerprint(ID, IsDefault), _flags(0){};

_ZN9OpenBabel9PatternFPC2EPKcS2_b:
   54|      4|      bool IsDefault=false) : OBFingerprint(ID, IsDefault)
   55|      4|  {
   56|      4|    if (filename == nullptr)
  ------------------
  |  Branch (56:9): [True: 2, False: 2]
  ------------------
   57|      2|      _patternsfile="patterns.txt";
   58|      2|    else
   59|      2|      _patternsfile = filename;
   60|      4|  }

_ZN9OpenBabel15fingerprintECFPC2EPKcbjb:
   37|     12|		: OBFingerprint(ID, IsDefault),
   38|     12|      _radius(radius), _keepdups(keepdups), _flags(0){};

_ZN9OpenBabel15OBFFConstraintsC2Ev:
  464|      2|  {
  465|      2|    _factor = 50000.0;
  466|      2|  }

_ZN9OpenBabel16OBForceFieldGaffC2EPKcb:
  123|      2|      explicit OBForceFieldGaff(const char* ID, bool IsDefault=true) : OBForceField(ID, IsDefault)
  124|      2|      {
  125|      2|        _validSetup = false;
  126|      2|        _init = false;
  127|      2|        _rvdw = 7.0;
  128|      2|        _rele = 15.0;
  129|      2|        _epsilon = 1.0;
  130|      2|        _pairfreq = 10;
  131|      2|        _cutoff = false;
  132|      2|        _linesearch = LineSearchType::Newton2Num;
  133|      2|      }

_ZN9OpenBabel20OBForceFieldGhemicalC2EPKcb:
  114|      2|      explicit OBForceFieldGhemical(const char* ID, bool IsDefault=true) : OBForceField(ID, IsDefault)
  115|      2|      {
  116|      2|        _validSetup = false;
  117|      2|        _init = false;
  118|      2|        _rvdw = 7.0;
  119|      2|        _rele = 15.0;
  120|      2|        _epsilon = 1.0;
  121|      2|        _pairfreq = 10;
  122|      2|        _cutoff = false;
  123|      2|        _linesearch = LineSearchType::Newton2Num;
  124|      2|      }

_ZN9OpenBabel18OBForceFieldMMFF94C2EPKcb:
  232|      4|      explicit OBForceFieldMMFF94(const char* ID, bool IsDefault=true) : OBForceField(ID, IsDefault)
  233|      4|      {
  234|      4|        _validSetup = false;
  235|      4|        _init = false;
  236|      4|        _rvdw = 7.0;
  237|      4|        _rele = 15.0;
  238|      4|        _epsilon = 1.0; // default electrostatics
  239|      4|        _pairfreq = 15;
  240|      4|        _cutoff = false;
  241|      4|        _linesearch = LineSearchType::Newton2Num;
  242|      4|        _gradientPtr = nullptr;
  243|      4|        _grad1 = nullptr;
  244|      4|	if (!strncmp(ID, "MMFF94s", 7)) {
  ------------------
  |  Branch (244:6): [True: 2, False: 2]
  ------------------
  245|      2|          mmff94s = true;
  246|      2|          _parFile = std::string("mmff94s.ff");
  247|      2|	} else {
  248|      2|          mmff94s = false;
  249|      2|          _parFile = std::string("mmff94.ff");
  250|      2|	}
  251|      4|      }

_ZN9OpenBabel15OBForceFieldUFFC2EPKcb:
  124|      2|    explicit OBForceFieldUFF(const char* ID, bool IsDefault=true) : OBForceField(ID, IsDefault)
  125|      2|    {
  126|      2|      _validSetup = false;
  127|      2|      _init = false;
  128|      2|      _rvdw = 7.0;
  129|      2|      _rele = 15.0;
  130|      2|      _epsilon = 1.0; // electrostatics not used
  131|      2|      _pairfreq = 10;
  132|      2|      _cutoff = false;
  133|      2|      _linesearch = LineSearchType::Newton2Num;
  134|      2|    }

_ZN9OpenBabel8OBFormat14RegisterFormatEPKcS2_:
   47|    322|{
   48|    322|  GetMap()[ID] = this;
   49|    322|  if (MIME)
  ------------------
  |  Branch (49:7): [True: 94, False: 228]
  ------------------
   50|     94|    FormatsMIMEMap()[MIME] = this;
   51|    322|  if(Flags() & DEFAULTFORMAT)
  ------------------
  |  |   40|    322|#define DEFAULTFORMAT   0x4000
  ------------------
  |  Branch (51:6): [True: 8, False: 314]
  ------------------
   52|      8|    Default() = this;
   53|       |
   54|       |  //ensure "formats" is registered as a plugin
   55|    322|  PluginMap()[TypeID()] =this;
   56|    322|  _id=ID;
   57|    322|  return GetMap().size();
   58|    322|}

_ZN9OpenBabel14OBAPIInterfaceC2Ev:
   29|      2|	{
   30|      2|		OBConversion::RegisterFormat("obapi",this);
   31|      2|		OBConversion::RegisterOptionParam("-errorlevel", this, 1, OBConversion::GENOPTIONS);
   32|      2|	}
_ZN9OpenBabel14OBAPIInterface5FlagsEv:
   41|      2|	unsigned int Flags() override { return (NOTWRITABLE | NOTREADABLE); }
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
              	unsigned int Flags() override { return (NOTWRITABLE | NOTREADABLE); }
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------

_ZN9OpenBabel9CSRFormatC2Ev:
   32|      2|    {
   33|      2|      OBConversion::RegisterFormat("csr",this);
   34|      2|    }
_ZN9OpenBabel9CSRFormat5FlagsEv:
   49|      2|    {
   50|      2|      return NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
   51|      2|    }

_ZN9OpenBabel10MCDLFormat4initEv:
  142|      2|  void MCDLFormat::init(){
  143|      2|    fsastart="{SA:";
  144|      2|    fsbstart="{SB:";
  145|      2|    fchstart="{CZ:";
  146|      2|    fradstart="{RA:";
  147|       |    //coordinates string
  148|      2|    fnastart="{NA:";
  149|      2|    fnbstart="{NB:";
  150|      2|    fzcoorstart="{ZV:";
  151|      2|    fablockstart="{CC:";
  152|      2|    fbblockstart="{BB:";
  153|      2|    fchargeblockstart="{MM:CHG,";
  154|      2|    fstereobondstart="{BS:";
  155|      2|    ftitlestart="{CN:}";
  156|       |
  157|      2|   };
_ZN9OpenBabel10MCDLFormatC2Ev:
   38|      2|  {
   39|      2|    OBConversion::RegisterFormat("mcdl",this);
   40|      2|    init();
   41|      2|  }
_ZN9OpenBabel10MCDLFormat5FlagsEv:
   72|      2|  {
   73|      2|      return 0;
   74|      2|  }

_ZN9OpenBabel9MNAFormatC2Ev:
   55|      2|			{
   56|      2|				OBConversion::RegisterFormat("mna", this);
   57|      2|				OBConversion::RegisterOptionParam(levels_option, this, 1);
   58|      2|			}
_ZN9OpenBabel9MNAFormat5FlagsEv:
  155|      2|			{
  156|      2|				return NOTREADABLE;	// possibly WRITEONEONLY??
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
  157|      2|			}

_ZN9OpenBabel9PQSFormatC2Ev:
   37|      2|    {
   38|      2|      OBConversion::RegisterFormat("pqs",this);
   39|      2|    }
_ZN9OpenBabel9PQSFormat5FlagsEv:
   54|      2|    {
   55|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   56|      2|    }

_ZN9OpenBabel12ABINITFormatC2Ev:
   39|      2|    {
   40|      2|      OBConversion::RegisterFormat("abinit",this);
   41|      2|    }
_ZN9OpenBabel12ABINITFormat5FlagsEv:
   58|      2|    {
   59|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   60|      2|    }

_ZN9OpenBabel16AcesOutputFormatC2Ev:
   38|      2|    {
   39|      2|      OBConversion::RegisterFormat("acesout",this);
   40|      2|    }
_ZN9OpenBabel15AcesInputFormatC2Ev:
   76|      2|    {
   77|      2|      OBConversion::RegisterFormat("acesin",this);
   78|      2|    }
_ZN9OpenBabel16AcesOutputFormat5FlagsEv:
   59|      2|    {
   60|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   61|      2|    }
_ZN9OpenBabel15AcesInputFormat5FlagsEv:
   95|      2|    {
   96|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   97|      2|    }

_ZN9OpenBabel9ACRFormatC2Ev:
   39|      2|    {
   40|      2|      OBConversion::RegisterFormat("acr", this, "chemical/x-acr");
   41|       |      //		OBConversion::RegisterOptionParam("f", this, 1);
   42|       |      //		OBConversion::RegisterOptionParam("n", this);
   43|      2|      OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS);
   44|       |
   45|      2|    }
_ZN9OpenBabel9ACRFormat5FlagsEv:
   66|      2|    {
   67|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   68|      2|    }

_ZN9OpenBabel15ADFOutputFormatC2Ev:
   63|      2|    {
   64|      2|      OBConversion::RegisterFormat("adfout",this);
   65|      2|    }
_ZN9OpenBabel14ADFInputFormatC2Ev:
  264|      2|    {
  265|      2|      OBConversion::RegisterFormat("adf", this);
  266|      2|    }
_ZN9OpenBabel13ADFBandFormatC2Ev:
  371|      2|    {
  372|      2|      OBConversion::RegisterFormat("adfband",this);
  373|      2|    }
_ZN9OpenBabel13ADFDftbFormatC2Ev:
  507|      2|    {
  508|      2|      OBConversion::RegisterFormat("adfdftb",this);
  509|      2|    }
_ZN9OpenBabel11OBT41FormatC2Ev:
  651|      2|    {
  652|      2|        OBConversion::RegisterFormat( "t41", this );
  653|      2|        OBConversion::RegisterFormat( "T41", this );
  654|      2|    }
_ZN9OpenBabel15ADFOutputFormat5FlagsEv:
   82|      2|    {
   83|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   84|      2|    }
_ZN9OpenBabel14ADFInputFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
  284|      1|      { return false; }
_ZN9OpenBabel14ADFInputFormat5FlagsEv:
  288|      6|    {
  289|      6|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      6|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      6|#define WRITEONEONLY    0x20
  ------------------
  290|      6|    }
_ZN9OpenBabel13ADFBandFormat5FlagsEv:
  386|      2|    {
  387|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
  388|      2|    }
_ZN9OpenBabel13ADFDftbFormat5FlagsEv:
  522|      2|    {
  523|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
  524|      2|    }
_ZN9OpenBabel11OBT41Format5FlagsEv:
  683|      4|    {
  684|      4|        return READONEONLY | READBINARY | NOTWRITABLE;
  ------------------
  |  |   32|      4|#define READONEONLY     0x02
  ------------------
                      return READONEONLY | READBINARY | NOTWRITABLE;
  ------------------
  |  |   33|      4|#define READBINARY      0x04
  ------------------
                      return READONEONLY | READBINARY | NOTWRITABLE;
  ------------------
  |  |   35|      4|#define NOTWRITABLE     0x10
  ------------------
  685|      4|    }

_ZN9OpenBabel13AlchemyFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("alc",this, "chemical/x-alchemy");
   37|      2|    }
_ZN9OpenBabel13AlchemyFormat5FlagsEv:
   55|      2|    {
   56|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   57|      2|    }

_ZN9OpenBabel15AmberPrepFormatC2Ev:
   34|      2|    {
   35|      2|        OBConversion::RegisterFormat("prep",this);
   36|      2|    }
_ZN9OpenBabel15AmberPrepFormat5FlagsEv:
   53|      2|    {
   54|      2|        return NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   55|      2|    }

_ZN9OpenBabel13AoforceFormatC2Ev:
   31|      2|    AoforceFormat() { OBConversion::RegisterFormat("aoforce", this); }
_ZN9OpenBabel13AoforceFormat5FlagsEv:
   43|      2|    unsigned int Flags() override { return READONEONLY | NOTWRITABLE; }
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                  unsigned int Flags() override { return READONEONLY | NOTWRITABLE; }
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------

_ZN9OpenBabel15BallStickFormatC2Ev:
   33|      2|    {
   34|      2|      OBConversion::RegisterFormat("bs",this);
   35|      2|    }
_ZN9OpenBabel15BallStickFormat5FlagsEv:
   51|      2|    {
   52|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   53|      2|    }

_ZN9OpenBabel9BGFFormatC2Ev:
   36|      2|    {
   37|      2|      OBConversion::RegisterFormat("bgf",this);
   38|      2|    }
_ZN9OpenBabel9BGFFormat5FlagsEv:
   53|      2|    {
   54|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   55|      2|    }

_ZN9OpenBabel9BoxFormatC2Ev:
   32|      2|    {
   33|      2|        OBConversion::RegisterFormat("box",this);
   34|      2|    }
_ZN9OpenBabel9BoxFormat5FlagsEv:
   49|      2|    {
   50|      2|        return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   51|      2|    }

_ZN9OpenBabel11CacaoFormatC2Ev:
   37|      2|    {
   38|      2|      OBConversion::RegisterFormat("caccrt",this);
   39|      2|    }
_ZN9OpenBabel19CacaoInternalFormatC2Ev:
  300|      2|    {
  301|      2|      OBConversion::RegisterFormat("cacint",this);
  302|      2|    }
_ZN9OpenBabel11CacaoFormat5FlagsEv:
   57|      2|    {
   58|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   59|      2|    }
_ZN9OpenBabel19CacaoInternalFormat5FlagsEv:
  318|      2|    {
  319|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
  320|      2|    }

_ZN9OpenBabel11CacheFormatC2Ev:
   32|      2|    {
   33|      2|      OBConversion::RegisterFormat("cac",this);
   34|      2|      OBConversion::RegisterFormat("cache",this);
   35|      2|    }
_ZN9OpenBabel11CacheFormat5FlagsEv:
   53|      4|    {
   54|      4|      return NOTREADABLE;
  ------------------
  |  |   31|      4|#define NOTREADABLE     0x01
  ------------------
   55|      4|    }

_ZN9OpenBabel9CARFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("car",this, "chemical/x-msi-car");
   37|      2|      OBConversion::RegisterFormat("arc",this, "chemical/x-msi-car");
   38|      2|    }
_ZN9OpenBabel9CARFormat5FlagsEv:
   57|      4|    {
   58|      4|      return NOTWRITABLE;
  ------------------
  |  |   35|      4|#define NOTWRITABLE     0x10
  ------------------
   59|      4|    }

_ZN9OpenBabel12CASTEPFormatC2Ev:
   36|      2|    {
   37|      2|      OBConversion::RegisterFormat("castep",this);
   38|      2|    }
_ZN9OpenBabel12CASTEPFormat5FlagsEv:
   54|      2|    {
   55|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   56|      2|    }

_ZN9OpenBabel9CCCFormatC2Ev:
   33|      2|    {
   34|      2|        OBConversion::RegisterFormat("ccc",this);
   35|      2|    }
_ZN9OpenBabel9CCCFormat5FlagsEv:
   50|      2|    {
   51|      2|        return NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   52|      2|    }

_ZN9OpenBabel13CHEM3D1FormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("c3d1",this);
   37|      2|    }
_ZN9OpenBabel13CHEM3D2FormatC2Ev:
  108|      2|    {
  109|      2|      OBConversion::RegisterFormat("c3d2",this);
  110|      2|    }
_ZN9OpenBabel13CHEM3D1Format5FlagsEv:
   52|      3|    {
   53|      3|      return READONEONLY;
  ------------------
  |  |   32|      3|#define READONEONLY     0x02
  ------------------
   54|      3|    }
_ZN9OpenBabel13CHEM3D2Format5FlagsEv:
  125|      2|    {
  126|      2|      return READONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
  127|      2|    }

_ZN9OpenBabel21ChemDrawBinaryXFormatC2Ev:
  128|      2|  {
  129|      2|    OBConversion::RegisterFormat("cdx",this);
  130|      2|  }
_ZN9OpenBabel21ChemDrawBinaryXFormat5FlagsEv:
  163|      2|  {
  164|      2|    return READBINARY|NOTWRITABLE;
  ------------------
  |  |   33|      2|#define READBINARY      0x04
  ------------------
                  return READBINARY|NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
  165|      2|  }

_ZN9OpenBabel14ChemDrawFormatC2Ev:
   33|      2|    {
   34|      2|      OBConversion::RegisterFormat("ct",this);
   35|      2|    }
_ZN9OpenBabel14ChemDrawFormat5FlagsEv:
   50|      3|    {
   51|      3|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      3|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      3|#define WRITEONEONLY    0x20
  ------------------
   52|      3|    }

_ZN9OpenBabel13ChemKinFormat4InitEv:
  217|      2|{    //initialize the member variables used during input
  218|      2|    ln.clear();
  219|      2|    AUnitsFactor = 1.0;
  220|      2|    EUnitsFactor = 1.0;
  221|      2|    SpeciesListed=false;
  222|      2|    IMols.clear();
  223|       |    //Special species name
  224|      2|    std::shared_ptr<OBMol> sp(new OBMol);
  225|      2|    sp.get()->SetTitle("M");
  226|      2|    IMols["M"] = sp;
  227|      2|}
_ZN9OpenBabel13ChemKinFormatC2Ev:
   48|      2|  {
   49|      2|    OBConversion::RegisterFormat("ck",this);
   50|      2|    OBConversion::RegisterOptionParam("s", this); //no params
   51|      2|    OBConversion::RegisterOptionParam("t", this);
   52|      2|    Init();
   53|      2|  }

_ZN9OpenBabel9CHTFormatC2Ev:
   62|      2|    {
   63|      2|      OBConversion::RegisterFormat("cht",this);
   64|      2|    }
_ZN9OpenBabel9CHTFormat5FlagsEv:
   79|      2|    {
   80|      2|      return NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
   81|      2|    }

_ZN9OpenBabel9CIFFormatC2Ev:
   62|      2|    {
   63|      2|      RegisterFormat("cif", "chemical/x-cif");
   64|      2|    }

_ZN9OpenBabel10CopyFormatC2Ev:
   25|      2|  {
   26|      2|    OBConversion::RegisterFormat("copy",this);
   27|      2|  }
_ZN9OpenBabel10CopyFormat5FlagsEv:
   55|      2|  {
   56|      2|      return NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
   57|      2|  }

_ZN9OpenBabel11CRK2DFormatC2Ev:
   34|      2|    {
   35|      2|      OBConversion::RegisterFormat("crk2d", this, "chemical/x-crk2d");
   36|      2|    }
_ZN9OpenBabel11CRK3DFormatC2Ev:
  137|      2|    {
  138|      2|      OBConversion::RegisterFormat("crk3d", this, "chemical/x-crk3d");
  139|      2|    }
_ZN9OpenBabel11CRK2DFormat5FlagsEv:
   54|      2|    {
   55|      2|      return READONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
   56|      2|    }
_ZN9OpenBabel11CRK3DFormat5FlagsEv:
  157|      2|    {
  158|      2|      return READONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
  159|      2|    }

_ZN9OpenBabel10CSSRFormatC2Ev:
   32|      2|    {
   33|      2|      OBConversion::RegisterFormat("cssr",this);
   34|      2|    }
_ZN9OpenBabel10CSSRFormat5FlagsEv:
   49|      5|    {
   50|      5|      return NOTREADABLE;
  ------------------
  |  |   31|      5|#define NOTREADABLE     0x01
  ------------------
   51|      5|    }

_ZN9OpenBabel17DlpolyInputReader11ParseHeaderERNSt3__113basic_istreamIcNS1_11char_traitsIcEEEERNS_5OBMolE:
  103|      4|  {
  104|       |
  105|       |    // Title line
  106|      4|    if ( ! ifs.getline(buffer,BUFF_SIZE) )
  ------------------
  |  |  771|      4|#define BUFF_SIZE 32768
  ------------------
  |  Branch (106:10): [True: 0, False: 4]
  ------------------
  107|      0|      {
  108|      0|        obErrorLog.ThrowError(__FUNCTION__, "Problem reading title line", obWarning);
  109|      0|        return false;
  110|      0|      }  
  111|      4|    title=buffer;
  112|      4|    Trim(title); // Remove leading & trailing space
  113|      4|    mol.BeginModify();
  114|      4|    mol.SetTitle(title);
  115|      4|    mol.EndModify();
  116|       |  
  117|       |    // levcfg, imcon & poss natms
  118|      4|    if ( ! ifs.getline(buffer,BUFF_SIZE) )
  ------------------
  |  |  771|      4|#define BUFF_SIZE 32768
  ------------------
  |  Branch (118:10): [True: 1, False: 3]
  ------------------
  119|      1|      {
  120|      1|        line=buffer;
  121|      1|        line="Problem reading levcfg line: " + line;
  122|      1|        obErrorLog.ThrowError(__FUNCTION__, line, obWarning);
  123|      1|        return false;
  124|      1|      }
  125|       |    
  126|      3|    tokenize(tokens, buffer, " \t\n");
  127|      3|    if ( tokens.size() < 2 || ! ( from_string<int>(levcfg, tokens.at(0), std::dec) 
  ------------------
  |  Branch (127:10): [True: 3, False: 0]
  |  Branch (127:35): [True: 0, False: 0]
  ------------------
  128|      0|                                     && from_string<int>(imcon, tokens.at(1), std::dec) ) )
  ------------------
  |  Branch (128:41): [True: 0, False: 0]
  ------------------
  129|      3|      {
  130|      3|        line=buffer;
  131|      3|        line="Problem reading keytrj line: " + line;
  132|      3|        obErrorLog.ThrowError(__FUNCTION__, line, obWarning);
  133|      3|        return false;
  134|      3|      }
  135|       |
  136|      0|    return true;
  137|       |
  138|      3|  } // End ParseHeader
_ZN9OpenBabel18DlpolyConfigFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
  299|      4|  {
  300|       |    
  301|      4|    bool ok;
  302|       |
  303|       |    // Reset data
  304|      4|    levcfg=0;
  305|      4|    imcon=0;
  306|      4|    forces.clear();
  307|       |
  308|      4|    OBMol* pmol = pOb->CastAndClear<OBMol>();
  309|      4|    if (pmol == nullptr)
  ------------------
  |  Branch (309:9): [True: 0, False: 4]
  ------------------
  310|      0|      return false;
  311|       |    
  312|       |    //Define some references so we can use the old parameter names
  313|      4|    std::istream &ifs = *pConv->GetInStream();
  314|      4|    OBMol &mol = *pmol;
  315|       |
  316|      4|    if ( ! ParseHeader( ifs, mol ) ) return false;
  ------------------
  |  Branch (316:10): [True: 4, False: 0]
  ------------------
  317|       |
  318|       |    // If imcon > 0 then there are 3 lines with the cell vectors
  319|      0|    if ( imcon > 0 ) ParseUnitCell( ifs, mol );
  ------------------
  |  Branch (319:10): [True: 0, False: 0]
  ------------------
  320|       |
  321|      0|    mol.BeginModify();
  322|      0|    ok = true;
  323|      0|    while ( ok )
  ------------------
  |  Branch (323:13): [True: 0, False: 0]
  ------------------
  324|      0|      {
  325|      0|        ok = ReadAtom( ifs, mol );
  326|      0|      } 
  327|       |
  328|       |    // Add forces as conformer data
  329|      0|    if ( levcfg > 1 && forces.size() )
  ------------------
  |  Branch (329:10): [True: 0, False: 0]
  |  Branch (329:24): [True: 0, False: 0]
  ------------------
  330|      0|      {
  331|      0|        OBConformerData * conformer = new OBConformerData();
  332|      0|        std::vector< std::vector< vector3 > > conflist;
  333|      0|        conflist.push_back( forces );
  334|      0|        conformer->SetForces( conflist );
  335|      0|        mol.SetData( conformer );
  336|      0|      }
  337|       |
  338|      0|    mol.EndModify();
  339|       |
  340|      0|    if ( mol.NumAtoms() == 0 )
  ------------------
  |  Branch (340:10): [True: 0, False: 0]
  ------------------
  341|      0|      return(false);
  342|      0|    else
  343|      0|      return(true);
  344|       |
  345|      0|  } // End ReadMolecule
_ZN9OpenBabel18DlpolyConfigFormatC2Ev:
  267|      2|    {
  268|      2|      OBConversion::RegisterFormat("CONFIG",this);
  269|      2|    }
_ZN9OpenBabel19DlpolyHISTORYFormatC2Ev:
  399|      2|  {
  400|      2|    OBConversion::RegisterFormat("HISTORY",this);
  401|      2|  }
_ZN9OpenBabel18DlpolyConfigFormat5FlagsEv:
  284|     19|    {
  285|     19|      return WRITEONEONLY;
  ------------------
  |  |   36|     19|#define WRITEONEONLY    0x20
  ------------------
  286|     19|    }
_ZN9OpenBabel19DlpolyHISTORYFormat5FlagsEv:
  416|      2|  {
  417|      2|    return NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
  418|      2|  }

_ZN9OpenBabel10DMolFormatC2Ev:
   38|      2|    {
   39|      2|      OBConversion::RegisterFormat("dmol",this);
   40|      2|      OBConversion::RegisterFormat("outmol",this, "chemical/x-dmol");
   41|      2|    }
_ZN9OpenBabel10DMolFormat5FlagsEv:
   58|      4|    {
   59|      4|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      4|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      4|#define WRITEONEONLY    0x20
  ------------------
   60|      4|    }

_ZN9OpenBabel10EXYZFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
  113|      1|  {
  114|      1|    OBMol* pmol = pOb->CastAndClear<OBMol>();
  115|      1|    if (pmol == nullptr)
  ------------------
  |  Branch (115:9): [True: 0, False: 1]
  ------------------
  116|      0|      return false;
  117|       |
  118|       |    //Define some references so we can use the old parameter names
  119|      1|    istream &ifs = *pConv->GetInStream();
  120|      1|    OBMol &mol = *pmol;
  121|      1|    const char* title = pConv->GetTitle();
  122|      1|    char buffer[BUFF_SIZE];
  123|       |
  124|      1|    stringstream errorMsg;
  125|      1|    bool unitCell,virtualAtoms;
  126|       |
  127|       |
  128|      1|    unsigned int natoms = 0;	// [ejk] assumed natoms could not be -ve
  129|       |
  130|      1|    if (!ifs)
  ------------------
  |  Branch (130:9): [True: 0, False: 1]
  ------------------
  131|      0|      return false; // we're attempting to read past the end of the file
  132|       |
  133|      1|    if (!ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      1|#define BUFF_SIZE 32768
  ------------------
  |  Branch (133:9): [True: 0, False: 1]
  ------------------
  134|      0|      {
  135|      0|        obErrorLog.ThrowError(__FUNCTION__,
  136|      0|                              "Problems reading an E-XYZ file: Cannot read the first line.", obWarning);
  137|      0|        return(false);
  138|      0|      }
  139|       |
  140|      1|    if (sscanf(buffer, "%u", &natoms) == 0 || !natoms || natoms >= 100000000)
  ------------------
  |  Branch (140:9): [True: 0, False: 1]
  |  Branch (140:47): [True: 1, False: 0]
  |  Branch (140:58): [True: 0, False: 0]
  ------------------
  141|      1|      {
  142|      1|        obErrorLog.ThrowError(__FUNCTION__,
  143|      1|                              "Problems reading an E-XYZ file: The first line must contain the number of atoms.", obWarning);
  144|      1|        return(false);
  145|      1|      }
  146|       |
  147|      0|    mol.ReserveAtoms(natoms);
  148|       |
  149|       |    // The next line contains a title string for the molecule. Use this
  150|       |    // as the title for the molecule if the line is not
  151|       |    // empty. Otherwise, use the title given by the calling function.
  152|      0|    if (!ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (152:9): [True: 0, False: 0]
  ------------------
  153|      0|      {
  154|      0|        obErrorLog.ThrowError(__FUNCTION__,
  155|      0|                              "Problems reading an EXYZ file: Could not read the second line (title/comments/keywords).", obWarning);
  156|      0|        return(false);
  157|      0|      }
  158|      0|    string readTitle(buffer);
  159|      0|    string::size_type location = readTitle.find("Energy");
  160|      0|    if (location != notFound)
  ------------------
  |  |   29|      0|#define notFound string::npos
  ------------------
  |  Branch (160:9): [True: 0, False: 0]
  ------------------
  161|      0|      readTitle.erase(location);
  162|      0|    Trim(readTitle);
  163|       |
  164|      0|    location = readTitle.find_first_not_of(" \t\n\r");
  165|      0|    if (readTitle.find_first_not_of(" \t\n\r") != notFound)
  ------------------
  |  |   29|      0|#define notFound string::npos
  ------------------
  |  Branch (165:9): [True: 0, False: 0]
  ------------------
  166|      0|      mol.SetTitle(readTitle);
  167|      0|    else
  168|      0|      mol.SetTitle(title);
  169|       |
  170|      0|    string readKeywords(buffer);
  171|      0|    location = readKeywords.find("%PBC");   // file contains unitcell information behind the coords block
  172|      0|    if (readKeywords.find("%PBC") != notFound)
  ------------------
  |  |   29|      0|#define notFound string::npos
  ------------------
  |  Branch (172:9): [True: 0, False: 0]
  ------------------
  173|      0|        unitCell = true;
  174|      0|    else
  175|      0|        unitCell = false;
  176|       |
  177|      0|    location = readKeywords.find("%VIRTUAL");   // file contains information about virtual atoms in the column next to the x,y,z values
  178|      0|    if (readKeywords.find("%VIRTUAL") != notFound)
  ------------------
  |  |   29|      0|#define notFound string::npos
  ------------------
  |  Branch (178:9): [True: 0, False: 0]
  ------------------
  179|      0|        virtualAtoms = true;
  180|      0|    else
  181|      0|        virtualAtoms = false;
  182|       |
  183|      0|    mol.BeginModify();
  184|       |
  185|       |    // The next lines contain four items each, separated by white
  186|       |    // spaces: the atom type, and the coordinates of the atom
  187|      0|    vector<string> vs;
  188|      0|    for (unsigned int i = 1; i <= natoms; i ++)
  ------------------
  |  Branch (188:30): [True: 0, False: 0]
  ------------------
  189|      0|      {
  190|      0|        if (!ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (190:13): [True: 0, False: 0]
  ------------------
  191|      0|          {
  192|      0|            errorMsg << "Problems reading an XYZ file: "
  193|      0|                     << "Could not read line #" << i+2 << ", file error." << endl
  194|      0|                     << " According to line one, there should be " << natoms
  195|      0|                     << " atoms, and therefore " << natoms+2 << " lines in the file.";
  196|       |
  197|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  198|      0|            return(false);
  199|      0|          }
  200|      0|        tokenize(vs,buffer);
  201|      0|        if (vs.size() < 4) // ignore extra columns which some applications add
  ------------------
  |  Branch (201:13): [True: 0, False: 0]
  ------------------
  202|      0|          {
  203|      0|            errorMsg << "Problems reading an XYZ file: "
  204|      0|                     << "Could not read line #" << i+2 << "." << endl
  205|      0|                     << "OpenBabel found the line '" << buffer << "'" << endl
  206|      0|                     << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  207|      0|                     << "However, OpenBabel found " << vs.size() << " items.";
  208|       |
  209|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  210|      0|            return(false);
  211|      0|          }
  212|       |
  213|       |        // Atom Type: get the atomic number from the element table, using
  214|       |        // the first entry in the currently read line. If the entry makes
  215|       |        // sense, set the atomic number and leave the atomic type open
  216|       |        // (the type is then later faulted in when atom->GetType() is
  217|       |        // called). If the entry does not make sense to use, set the atom
  218|       |        // type manually, assuming that the author of the xyz-file had
  219|       |        // something "special" in mind.
  220|      0|        OBAtom *atom  = mol.NewAtom();
  221|       |
  222|      0|        int atomicNum = OBElements::GetAtomicNum(vs[0].c_str());
  223|       |        //set atomic number, or '0' if the atom type is not recognized
  224|      0|        if (atomicNum == 0) {
  ------------------
  |  Branch (224:13): [True: 0, False: 0]
  ------------------
  225|       |          // Sometimes people call this an XYZ file, but it's actually Unichem
  226|       |          // i.e., the first column is the atomic number, not a symbol
  227|       |          // so we'll first check if we can convert this to an element number
  228|      0|          atomicNum = atoi(vs[0].c_str());
  229|      0|        }
  230|       |
  231|      0|        atom->SetAtomicNum(atomicNum);
  232|      0|        if (atomicNum == 0) // still strange, try using an atom type
  ------------------
  |  Branch (232:13): [True: 0, False: 0]
  ------------------
  233|      0|          atom->SetType(vs[0]);
  234|       |
  235|       |        // Read the atom coordinates
  236|      0|        char *endptr;
  237|      0|        double x = strtod((char*)vs[1].c_str(),&endptr);
  238|      0|        if (endptr == (char*)vs[1].c_str())
  ------------------
  |  Branch (238:13): [True: 0, False: 0]
  ------------------
  239|      0|          {
  240|      0|            errorMsg << "Problems reading an XYZ file: "
  241|      0|                     << "Could not read line #" << i+2 << "." << endl
  242|      0|                     << "OpenBabel found the line '" << buffer << "'" << endl
  243|      0|                     << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  244|      0|                     << "OpenBabel could not interpret item #1 as a number.";
  245|       |
  246|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  247|      0|            return(false);
  248|      0|          }
  249|      0|        double y = strtod((char*)vs[2].c_str(),&endptr);
  250|      0|        if (endptr == (char*)vs[2].c_str())
  ------------------
  |  Branch (250:13): [True: 0, False: 0]
  ------------------
  251|      0|          {
  252|      0|            errorMsg << "Problems reading an XYZ file: "
  253|      0|                     << "Could not read line #" << i+2 << "." << endl
  254|      0|                     << "OpenBabel found the line '" << buffer << "'" << endl
  255|      0|                     << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  256|      0|                     << "OpenBabel could not interpret item #2 as a number.";
  257|       |
  258|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  259|      0|            return(false);
  260|      0|          }
  261|      0|        double z = strtod((char*)vs[3].c_str(),&endptr);
  262|      0|        if (endptr == (char*)vs[3].c_str())
  ------------------
  |  Branch (262:13): [True: 0, False: 0]
  ------------------
  263|      0|          {
  264|      0|            errorMsg << "Problems reading an XYZ file: "
  265|      0|                     << "Could not read line #" << i+2 << "." << endl
  266|      0|                     << "OpenBabel found the line '" << buffer << "'" << endl
  267|      0|                     << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  268|      0|                     << "OpenBabel could not interpret item #3 as a number.";
  269|       |
  270|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  271|      0|            return(false);
  272|      0|          }
  273|      0|        atom->SetVector(x,y,z); //set coordinates
  274|       |
  275|       |        // OK, sometimes there's sym x y z charge -- accepted by Jmol
  276|      0|        if (vs.size() > 5) {
  ------------------
  |  Branch (276:13): [True: 0, False: 0]
  ------------------
  277|      0|          string::size_type decimal = vs[4].find('.');
  278|      0|          if (decimal !=string::npos) { // period found
  ------------------
  |  Branch (278:15): [True: 0, False: 0]
  ------------------
  279|      0|            double charge = strtod((char*)vs[4].c_str(),&endptr);
  280|      0|            if (endptr != (char*)vs[4].c_str())
  ------------------
  |  Branch (280:17): [True: 0, False: 0]
  ------------------
  281|      0|              atom->SetPartialCharge(charge);
  282|      0|          }
  283|      0|        } // attempt to parse charges
  284|      0|      }
  285|      0|    if (!ifs.getline(buffer,BUFF_SIZE)) {           // skip empty line
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (285:9): [True: 0, False: 0]
  ------------------
  286|      0|        errorMsg << "Problems reading an EXYZ file: "
  287|      0|                 << "Expecting unitcell information because of keyword %PBC " << endl
  288|      0|                 << " but nothing more found ";
  289|      0|        obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  290|      0|        return(false);
  291|      0|    }
  292|      0|    if (unitCell) {
  ------------------
  |  Branch (292:9): [True: 0, False: 0]
  ------------------
  293|      0|        OBUnitCell *unitCellInfo = new OBUnitCell;
  294|      0|        matrix3x3 unitCellMatrix;
  295|      0|        for (unsigned int i = 1; i <= 3; i ++) {
  ------------------
  |  Branch (295:34): [True: 0, False: 0]
  ------------------
  296|      0|            if (!ifs.getline(buffer,BUFF_SIZE)) {
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (296:17): [True: 0, False: 0]
  ------------------
  297|      0|                errorMsg << "Problems reading an EXYZ file: "
  298|      0|                         << "Expecting unitcell information because of keyword %PBC " << endl
  299|      0|                         << " but nothing found ";
  300|      0|                obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  301|      0|                return(false);
  302|      0|            }
  303|      0|            tokenize(vs,buffer);
  304|      0|            if (vs.size() != 4) { // assume that unit cell vectors are given
  ------------------
  |  Branch (304:17): [True: 0, False: 0]
  ------------------
  305|      0|                errorMsg << "Problems reading an EXYZ file: "
  306|      0|                         << "OpenBabel found the line '" << buffer << "'" << endl
  307|      0|                         << "According to the specifications (keyword %PBC), this line should contain exactly 4 entries, separated by white space." << endl
  308|      0|                         << "However, OpenBabel found " << vs.size() << " items.";
  309|      0|                obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  310|      0|                return(false);
  311|      0|            }
  312|       |            // Read the vectors of the unit cell
  313|      0|            char *endptr;
  314|      0|            double x = strtod((char*)vs[1].c_str(),&endptr);
  315|      0|            if (endptr == (char*)vs[1].c_str())
  ------------------
  |  Branch (315:17): [True: 0, False: 0]
  ------------------
  316|      0|            {
  317|      0|                errorMsg << "Problems reading an EXYZ file: "
  318|      0|                         << "Could not read line #" << i+2 << "." << endl
  319|      0|                         << "OpenBabel found the line '" << buffer << "'" << endl
  320|      0|                         << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  321|      0|                         << "OpenBabel could not interpret item #1 as a number.";
  322|       |
  323|      0|                obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  324|      0|                return(false);
  325|      0|            }
  326|      0|            double y = strtod((char*)vs[2].c_str(),&endptr);
  327|      0|            if (endptr == (char*)vs[2].c_str())
  ------------------
  |  Branch (327:17): [True: 0, False: 0]
  ------------------
  328|      0|            {
  329|      0|                errorMsg << "Problems reading an EXYZ file: "
  330|      0|                         << "Could not read line #" << i+2 << "." << endl
  331|      0|                         << "OpenBabel found the line '" << buffer << "'" << endl
  332|      0|                         << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  333|      0|                         << "OpenBabel could not interpret item #2 as a number.";
  334|       |
  335|      0|                obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  336|      0|                return(false);
  337|      0|            }
  338|      0|            double z = strtod((char*)vs[3].c_str(),&endptr);
  339|      0|            if (endptr == (char*)vs[3].c_str())
  ------------------
  |  Branch (339:17): [True: 0, False: 0]
  ------------------
  340|      0|            {
  341|      0|                errorMsg << "Problems reading an EXYZ file: "
  342|      0|                         << "Could not read line #" << i+2 << "." << endl
  343|      0|                         << "OpenBabel found the line '" << buffer << "'" << endl
  344|      0|                         << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  345|      0|                         << "OpenBabel could not interpret item #3 as a number.";
  346|       |
  347|      0|                obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  348|      0|                return(false);
  349|      0|            }
  350|      0|            unitCellMatrix.SetRow(i-1, vector3(x,y,z));
  351|      0|        }
  352|      0|        unitCellInfo->SetData(unitCellMatrix);
  353|       |
  354|      0|        if (!ifs.getline(buffer,BUFF_SIZE)) {
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (354:13): [True: 0, False: 0]
  ------------------
  355|      0|            errorMsg << "Problems reading an EXYZ file: "
  356|      0|                     << "Expecting unitcell information because of keyword %PBC " << endl
  357|      0|                     << " looking for center information but nothing found ";
  358|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  359|      0|            return(false);
  360|      0|        }
  361|      0|        tokenize(vs,buffer);
  362|      0|        if (vs.size() != 4) { // assume that unit cell vectors are given
  ------------------
  |  Branch (362:13): [True: 0, False: 0]
  ------------------
  363|      0|            errorMsg << "Problems reading an EXYZ file: "
  364|      0|                     << "OpenBabel found the line '" << buffer << "'" << endl
  365|      0|                     << "According to the specifications (keyword %PBC), this line should contain exactly 4 entries, separated by white space." << endl
  366|      0|                     << "However, OpenBabel found " << vs.size() << " items.";
  367|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  368|      0|            return(false);
  369|      0|        }
  370|       |        // Read the origin (center) vector of the unit cell
  371|      0|        char *endptr;
  372|      0|        double x = strtod((char*)vs[1].c_str(),&endptr);
  373|      0|        if (endptr == (char*)vs[1].c_str())
  ------------------
  |  Branch (373:13): [True: 0, False: 0]
  ------------------
  374|      0|        {
  375|      0|            errorMsg << "Problems reading an EXYZ file: "
  376|      0|                     << "OpenBabel found the line '" << buffer << "'" << endl
  377|      0|                     << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  378|      0|                     << "OpenBabel could not interpret item #1 as a number.";
  379|       |
  380|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  381|      0|            return(false);
  382|      0|        }
  383|      0|        double y = strtod((char*)vs[2].c_str(),&endptr);
  384|      0|        if (endptr == (char*)vs[2].c_str())
  ------------------
  |  Branch (384:13): [True: 0, False: 0]
  ------------------
  385|      0|        {
  386|      0|            errorMsg << "Problems reading an EXYZ file: "
  387|      0|                     << "OpenBabel found the line '" << buffer << "'" << endl
  388|      0|                     << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  389|      0|                     << "OpenBabel could not interpret item #2 as a number.";
  390|       |
  391|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  392|      0|            return(false);
  393|      0|        }
  394|      0|        double z = strtod((char*)vs[3].c_str(),&endptr);
  395|      0|        if (endptr == (char*)vs[3].c_str())
  ------------------
  |  Branch (395:13): [True: 0, False: 0]
  ------------------
  396|      0|        {
  397|      0|            errorMsg << "Problems reading an EXYZ file: "
  398|      0|                     << "OpenBabel found the line '" << buffer << "'" << endl
  399|      0|                     << "According to the specifications, this line should contain exactly 4 entries, separated by white space." << endl
  400|      0|                     << "OpenBabel could not interpret item #3 as a number.";
  401|       |
  402|      0|            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str() , obWarning);
  403|      0|            return(false);
  404|      0|        }
  405|      0|        unitCellInfo->SetOffset(vector3(x,y,z));
  406|      0|        mol.SetData(unitCellInfo);
  407|      0|    }
  408|       |
  409|       |
  410|       |    // clean out any remaining blank lines
  411|      0|    std::streampos ipos;
  412|      0|    do
  413|      0|    {
  414|      0|      ipos = ifs.tellg();
  415|      0|      ifs.getline(buffer,BUFF_SIZE);
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  416|      0|    }
  417|      0|    while(strlen(buffer) == 0 && !ifs.eof() );
  ------------------
  |  Branch (417:11): [True: 0, False: 0]
  |  Branch (417:34): [True: 0, False: 0]
  ------------------
  418|      0|    ifs.seekg(ipos);
  419|       |
  420|      0|    if (!pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (420:9): [True: 0, False: 0]
  ------------------
  421|      0|      mol.ConnectTheDots();
  422|      0|    if (!pConv->IsOption("s",OBConversion::INOPTIONS) && !pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (422:9): [True: 0, False: 0]
  |  Branch (422:58): [True: 0, False: 0]
  ------------------
  423|      0|      mol.PerceiveBondOrders();
  424|       |
  425|      0|    mol.EndModify();
  426|       |
  427|      0|    return(true);
  428|      0|  }
_ZN9OpenBabel10EXYZFormatC2Ev:
   40|      2|    {
   41|      2|      OBConversion::RegisterFormat("exyz", this, "chemical/x-xyz");
   42|      2|    }

_ZN9OpenBabel11FASTAFormatC2Ev:
   40|      2|    FASTAFormat() {
   41|      2|      OBConversion::RegisterFormat("fasta", this, "chemical/x-fasta");
   42|      2|      OBConversion::RegisterFormat("fa", this);
   43|      2|      OBConversion::RegisterFormat("fsa", this);
   44|       |
   45|      2|      OBConversion::RegisterOptionParam("s", this);
   46|      2|      OBConversion::RegisterOptionParam("b", this);
   47|      2|      OBConversion::RegisterOptionParam("n", this);
   48|      2|      OBConversion::RegisterOptionParam("1", this);
   49|      2|      OBConversion::RegisterOptionParam("t", nullptr, 1, OBConversion::INOPTIONS);
   50|      2|    }
_ZN9OpenBabel11FASTAFormat5FlagsEv:
   74|      6|    unsigned int Flags() override {
   75|      6|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      6|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      6|#define WRITEONEONLY    0x20
  ------------------
   76|      6|    }

_ZN9OpenBabel16FastSearchFormatC2Ev:
   39|      2|FastSearchFormat() : fsi(nullptr)
   40|      2|{
   41|      2|  OBConversion::RegisterFormat("fs",this);
   42|       |  //Specify the number of option taken by options
   43|      2|  OBConversion::RegisterOptionParam("S", this, 1, OBConversion::GENOPTIONS);
   44|      2|  OBConversion::RegisterOptionParam("S", this, 1, OBConversion::INOPTIONS);
   45|      2|  OBConversion::RegisterOptionParam("f", this, 1);
   46|      2|  OBConversion::RegisterOptionParam("N", this, 1);
   47|      2|  OBConversion::RegisterOptionParam("u", this, 0);
   48|      2|  OBConversion::RegisterOptionParam("t", this, 1, OBConversion::INOPTIONS);
   49|      2|  OBConversion::RegisterOptionParam("l", this, 1, OBConversion::INOPTIONS);
   50|      2|  OBConversion::RegisterOptionParam("a", this, 0, OBConversion::INOPTIONS);
   51|      2|  OBConversion::RegisterOptionParam("e", this, 0, OBConversion::INOPTIONS);
   52|      2|}
_ZN9OpenBabel16FastSearchFormat5FlagsEv:
  107|      2|  unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; }
  ------------------
  |  |   33|      2|#define READBINARY      0x04
  ------------------
                unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; }
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; }
  ------------------
  |  |   37|      2|#define WRITEBINARY     0x40
  ------------------

_ZN9OpenBabel10FCHKFormatC2Ev:
   50|      2|    {
   51|      2|      OBConversion::RegisterFormat("fchk", this,
   52|      2|                                   "chemical/x-gaussian-checkpoint");
   53|      2|      OBConversion::RegisterFormat("fch", this,
   54|      2|                                   "chemical/x-gaussian-checkpoint");
   55|      2|      OBConversion::RegisterFormat("fck", this,
   56|      2|                                   "chemical/x-gaussian-checkpoint");
   57|      2|    }
_ZN9OpenBabel10FCHKFormat5FlagsEv:
   78|      6|    {
   79|      6|      return NOTWRITABLE;
  ------------------
  |  |   35|      6|#define NOTWRITABLE     0x10
  ------------------
   80|      6|    }

_ZN9OpenBabel10FEATFormatC2Ev:
   32|      2|    {
   33|      2|      OBConversion::RegisterFormat("feat",this);
   34|      2|    }
_ZN9OpenBabel10FEATFormat5FlagsEv:
   51|      2|    {
   52|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   53|      2|    }

_ZN9OpenBabel16FenskeZmatFormatC2Ev:
   33|      2|    {
   34|      2|        OBConversion::RegisterFormat("fh",this);
   35|      2|    }
_ZN9OpenBabel16FenskeZmatFormat5FlagsEv:
   50|      2|    {
   51|      2|        return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   52|      2|    }

_ZN9OpenBabel13FHIaimsFormatC2Ev:
   35|      2|    {
   36|      2|        OBConversion::RegisterFormat("fhiaims",this);
   37|      2|    }
_ZN9OpenBabel13FHIaimsFormat5FlagsEv:
   55|      2|    {
   56|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   57|      2|    }

_ZN9OpenBabel17FingerprintFormatC2Ev:
   36|      2|    FingerprintFormat() {OBConversion::RegisterFormat("fpt",this);}
_ZN9OpenBabel17FingerprintFormat5FlagsEv:
  111|      2|    unsigned int Flags() override { return NOTREADABLE; }
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------

_ZN9OpenBabel24FreeFormFractionalFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("fract",this);
   37|      2|    }

_ZN9OpenBabel18GAMESSOutputFormatC2Ev:
   41|      2|      GAMESSOutputFormat() {
   42|      2|        OBConversion::RegisterFormat("gam",    this, "chemical/x-gamess-output");
   43|      2|        OBConversion::RegisterFormat("gamout", this);
   44|      2|        OBConversion::RegisterFormat("gamess", this);
   45|      2|      }
_ZN9OpenBabel17GAMESSInputFormatC2Ev:
   86|      2|      GAMESSInputFormat() {
   87|      2|        OBConversion::RegisterFormat("inp",   this, "chemical/x-gamess-input");
   88|      2|        OBConversion::RegisterFormat("gamin", this);
   89|       |        // Command-line keywords
   90|      2|        OBConversion::RegisterOptionParam("k", nullptr, 1, OBConversion::OUTOPTIONS);
   91|       |        // Command-line keyword file
   92|      2|        OBConversion::RegisterOptionParam("f", nullptr, 1, OBConversion::OUTOPTIONS);
   93|      2|      }
_ZN9OpenBabel18GAMESSOutputFormat5FlagsEv:
   69|      6|      unsigned int Flags() override {
   70|      6|        return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      6|#define READONEONLY     0x02
  ------------------
                      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      6|#define NOTWRITABLE     0x10
  ------------------
   71|      6|      }
_ZN9OpenBabel17GAMESSInputFormat5FlagsEv:
  116|      4|      unsigned int Flags() override {
  117|      4|        return WRITEONEONLY; // | NOTREADABLE;
  ------------------
  |  |   36|      4|#define WRITEONEONLY    0x20
  ------------------
  118|      4|      }

_ZN9OpenBabel20OBGaussianCubeFormatC2Ev:
   57|      2|    {
   58|      2|        OpenBabel::OBConversion::RegisterFormat( "cube", this );
   59|      2|        OpenBabel::OBConversion::RegisterFormat( "cub", this );
   60|      2|    }
_ZN9OpenBabel20OBGaussianCubeFormat5FlagsEv:
   90|      4|    {
   91|      4|        return 0;
   92|      4|    }

_ZN9OpenBabel20GaussianOutputFormatC2Ev:
   38|      2|    {
   39|      2|      OBConversion::RegisterFormat("gal",this, "chemical/x-gaussian-log");
   40|      2|      OBConversion::RegisterFormat("g92",this);
   41|      2|      OBConversion::RegisterFormat("g94",this);
   42|      2|      OBConversion::RegisterFormat("g98",this);
   43|      2|      OBConversion::RegisterFormat("g03",this);
   44|      2|      OBConversion::RegisterFormat("g09",this);
   45|      2|      OBConversion::RegisterFormat("g16",this);
   46|      2|    }
_ZN9OpenBabel19GaussianInputFormatC2Ev:
   82|      2|    {
   83|      2|      OBConversion::RegisterFormat("com",this, "chemical/x-gaussian-input");
   84|      2|      OBConversion::RegisterFormat("gau",this);
   85|      2|      OBConversion::RegisterFormat("gjc",this);
   86|      2|      OBConversion::RegisterFormat("gjf",this);
   87|      2|      OBConversion::RegisterOptionParam("b", nullptr, 0, OBConversion::OUTOPTIONS);
   88|       |      // Command-line keywords
   89|      2|      OBConversion::RegisterOptionParam("k", nullptr, 1, OBConversion::OUTOPTIONS);
   90|       |      // Command-line keyword file
   91|      2|      OBConversion::RegisterOptionParam("f", nullptr, 1, OBConversion::OUTOPTIONS);
   92|      2|    }
_ZN9OpenBabel20GaussianOutputFormat5FlagsEv:
   66|     14|    {
   67|     14|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|     14|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|     14|#define NOTWRITABLE     0x10
  ------------------
   68|     14|    }
_ZN9OpenBabel19GaussianInputFormat5FlagsEv:
  114|      8|    {
  115|      8|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      8|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      8|#define WRITEONEONLY    0x20
  ------------------
  116|      8|    }

_ZN9OpenBabel26GaussianZMatrixInputFormatC2Ev:
   43|      2|    {
   44|      2|      OBConversion::RegisterFormat("gzmat",this, "chemical/x-gaussian-input");
   45|      2|    }

_ZN9OpenBabel13GenBankFormatC2Ev:
   32|      2|    { // Copied from the Chemical MIME Page at http://www.ch.ic.ac.uk/chemime/
   33|      2|      OBConversion::RegisterFormat("gen", this, "chemical/x-genbank");
   34|      2|      OBConversion::RegisterFormat("embl", this);
   35|      2|      OBConversion::RegisterFormat("ddbj", this);
   36|       |
   37|      2|      OBConversion::RegisterOptionParam("s", this);
   38|      2|      OBConversion::RegisterOptionParam("b", this);
   39|      2|    }
_ZN9OpenBabel13GenBankFormat5FlagsEv:
   61|      6|    { return NOTWRITABLE | READONEONLY; }
  ------------------
  |  |   35|      6|#define NOTWRITABLE     0x10
  ------------------
                  { return NOTWRITABLE | READONEONLY; }
  ------------------
  |  |   32|      6|#define READONEONLY     0x02
  ------------------

_ZN9OpenBabel14GhemicalFormatC2Ev:
   36|      2|      {
   37|       |        //        OBConversion::RegisterFormat("mm1gp",this);
   38|       |        //        OBConversion::RegisterFormat("qm1gp",this);
   39|      2|        OBConversion::RegisterFormat("gpr",this);
   40|      2|      }
_ZN9OpenBabel14GhemicalFormat5FlagsEv:
   56|      2|      {
   57|      2|        return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   58|      2|      }

_ZN9OpenBabel9GROFormatC2Ev:
   36|      2|  {
   37|       |    /* GRO is the file extension and is case insensitive. A MIME type can be
   38|       |       added as an optional third parameter.
   39|       |       Multiple file extensions can be registered by adding extra statements.*/
   40|      2|    OBConversion::RegisterFormat("gro",this);
   41|       |
   42|       |    /* If there are any format specific options they should be registered here
   43|       |       so that the commandline interface works properly.
   44|       |       The first parameter is the option name. If it is a single letter it can
   45|       |       be concatinated with other single letter options. For output options it
   46|       |       can be multicharcter and is then written as --optionname on the command
   47|       |       line. The third parameter is the number of parameters the option takes.
   48|       |       Currently this is either 1 or 0 and if it is 0 can be omitted for output
   49|       |       options. The parameter is always text and needs to be parsed to extract
   50|       |       a number.
   51|       |
   52|       |       Options can apply when writing - 4th parameter is
   53|       |       OBConversion::OUTOPTIONS or can be omitted as shown. A single letter
   54|       |       output option is preceded by -x on the command line.
   55|       |       Or options can apply to the input format - the 4th parameter is
   56|       |       OBConversion::INOPTIONS. They are then preceded by -a on the command
   57|       |       line.
   58|       |
   59|       |       Each option letter may be reused in other formats, but within the same
   60|       |       group, INOPTIONS or OUTOPTIONS, must take the same number of parameters
   61|       |       (0 or 1). There will be an error message when OpenBabel  runs if there
   62|       |       are conflicts between formats. A list of formats currently used (which
   63|       |       may not be comprehensive) is in docs/options.html.
   64|       |    */
   65|      2|    OBConversion::RegisterOptionParam("f", this, 1);
   66|      2|    OBConversion::RegisterOptionParam("n", this);
   67|      2|    OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS);
   68|       |
   69|      2|  }

_ZN9OpenBabel14GROMOS96FormatC2Ev:
   69|      2|    {
   70|      2|      OBConversion::RegisterFormat("gr96",this);
   71|      2|    }
_ZN9OpenBabel14GROMOS96Format5FlagsEv:
   89|      2|    {
   90|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   91|      2|    }

_ZN9OpenBabel10GULPFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("got",this);
   37|      2|    }
_ZN9OpenBabel10GULPFormat5FlagsEv:
   53|      2|    {
   54|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   55|      2|    }

_ZN9OpenBabel9HINFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("hin",this, "chemical/x-hin");
   37|      2|    }

_ZN9OpenBabel18JaguarOutputFormatC2Ev:
   37|      2|    {
   38|      2|      OBConversion::RegisterFormat("jout",this);
   39|      2|    }
_ZN9OpenBabel17JaguarInputFormatC2Ev:
   72|      2|    {
   73|      2|      OBConversion::RegisterFormat("jin",this);
   74|      2|    }
_ZN9OpenBabel18JaguarOutputFormat5FlagsEv:
   55|      2|    unsigned int Flags() override { return READONEONLY | NOTWRITABLE; }
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                  unsigned int Flags() override { return READONEONLY | NOTWRITABLE; }
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
_ZN9OpenBabel17JaguarInputFormat5FlagsEv:
   90|      2|    unsigned int Flags() override { return WRITEONEONLY; }
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------

_ZN9OpenBabel12LMPDATFormatC2Ev:
   36|      2|    {
   37|      2|      OBConversion::RegisterFormat("lmpdat", this, "chemical/x-lmpdat");
   38|      2|      OBConversion::RegisterOptionParam("q", nullptr, 1, OBConversion::OUTOPTIONS);
   39|      2|      OBConversion::RegisterOptionParam("d", nullptr, 1, OBConversion::OUTOPTIONS);
   40|      2|    }
_ZN9OpenBabel12LMPDATFormat5FlagsEv:
   65|      2|    {
   66|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   67|      2|    }

_ZN9OpenBabel9MOLFormatC2Ev:
  175|      2|      {
  176|      2|        OBConversion::RegisterFormat("mol",this, "chemical/x-mdl-molfile");
  177|      2|        OBConversion::RegisterFormat("mdl",this, "chemical/x-mdl-molfile");
  178|      2|        OBConversion::RegisterOptionParam("2", this);
  179|      2|        OBConversion::RegisterOptionParam("3", this);
  180|      2|      }
_ZN9OpenBabel8SDFormatC2Ev:
  191|      2|      {
  192|      2|        OBConversion::RegisterFormat("sd",this, "chemical/x-mdl-sdfile");
  193|      2|        OBConversion::RegisterFormat("sdf",this, "chemical/x-mdl-sdfile");
  194|      2|      }
_ZN9OpenBabel9MDLFormat5FlagsEv:
  118|      8|      unsigned int Flags() override { return DEFAULTFORMAT | ZEROATOMSOK; }
  ------------------
  |  |   40|      8|#define DEFAULTFORMAT   0x4000
  ------------------
                    unsigned int Flags() override { return DEFAULTFORMAT | ZEROATOMSOK; }
  ------------------
  |  |   34|      8|#define ZEROATOMSOK     0x08
  ------------------

_ZN9OpenBabel11mmCIFFormatC2Ev:
   41|      2|   { // Copied from the Chemical MIME Page at http://www.ch.ic.ac.uk/chemime/
   42|      2|     OBConversion::RegisterFormat("mcif", this, "chemical/x-mmcif");
   43|      2|     OBConversion::RegisterFormat("mmcif", this, "chemical/x-mmcif");
   44|       |     // Uncomment the following line, and this file will handle all CIF formats
   45|       |     // OBConversion::RegisterFormat("cif", this, "chemical/x-cif");
   46|       |
   47|      2|     OBConversion::RegisterOptionParam("s", this);
   48|      2|     OBConversion::RegisterOptionParam("p", this);
   49|      2|     OBConversion::RegisterOptionParam("b", this);
   50|      2|     OBConversion::RegisterOptionParam("w", this);
   51|      2|   }

_ZN9OpenBabel14MacroModFormatC2Ev:
   36|      2|    {
   37|      2|      OBConversion::RegisterFormat("mmd",this, "chemical/x-macromodel-input");
   38|      2|      OBConversion::RegisterFormat("mmod",this, "chemical/x-macromodel-input");
   39|      2|    }
_ZN9OpenBabel14MacroModFormat5FlagsEv:
   57|      4|    {
   58|      4|      return READONEONLY;
  ------------------
  |  |   32|      4|#define READONEONLY     0x02
  ------------------
   59|      4|    }

_ZN9OpenBabel10MOL2FormatC2Ev:
   41|      2|    {
   42|      2|      OBConversion::RegisterFormat("mol2",this, "chemical/x-mol2");
   43|      2|      OBConversion::RegisterFormat("ml2",this);
   44|      2|      OBConversion::RegisterFormat("sy2",this);
   45|      2|      OBConversion::RegisterOptionParam("c", this, 0, OBConversion::INOPTIONS);
   46|      2|      OBConversion::RegisterOptionParam("c", this, 0, OBConversion::OUTOPTIONS);
   47|      2|      OBConversion::RegisterOptionParam("l", this, 0, OBConversion::OUTOPTIONS);
   48|      2|      OBConversion::RegisterOptionParam("u", this, 0, OBConversion::OUTOPTIONS);
   49|      2|    }

_ZN9OpenBabel14OBMoldenFormatC2Ev:
   58|      2|    {
   59|      2|        OBConversion::RegisterFormat( "molden", this );
   60|      2|        OBConversion::RegisterFormat( "mold", this );
   61|      2|        OBConversion::RegisterFormat( "molf", this );
   62|      2|    }
_ZN9OpenBabel14OBMoldenFormat5FlagsEv:
   86|      6|    {
   87|      6|        return READONEONLY | WRITEONEONLY ;
  ------------------
  |  |   32|      6|#define READONEONLY     0x02
  ------------------
                      return READONEONLY | WRITEONEONLY ;
  ------------------
  |  |   36|      6|#define WRITEONEONLY    0x20
  ------------------
   88|      6|    }

_ZN9OpenBabel18MolproOutputFormatC2Ev:
   40|      2|    {
   41|      2|      OBConversion::RegisterFormat("mpo",this);
   42|      2|    }
_ZN9OpenBabel17MolproInputFormatC2Ev:
   76|      2|    {
   77|      2|      OBConversion::RegisterFormat("mp",this);
   78|      2|    }
_ZN9OpenBabel18MolproOutputFormat5FlagsEv:
   59|      2|    {
   60|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   61|      2|    }
_ZN9OpenBabel17MolproInputFormat5FlagsEv:
   93|      2|    {
   94|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   95|      2|    }

_ZN9OpenBabel15MolReportFormatC2Ev:
   37|      2|    {
   38|      2|      OBConversion::RegisterFormat("molreport",this);
   39|      2|    }
_ZN9OpenBabel15MolReportFormat5FlagsEv:
   82|      2|    {
   83|      2|      return NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
   84|      2|    }

_ZN9OpenBabel11MOPACFormatC2Ev:
   36|      2|    {
   37|      2|      OBConversion::RegisterFormat("mopout",this, "chemical/x-mopac-out");
   38|      2|      OBConversion::RegisterFormat("moo",this, "chemical/x-mopac-out");
   39|      2|    }
_ZN9OpenBabel15MOPACCARTFormatC2Ev:
  514|      2|    {
  515|      2|      OBConversion::RegisterFormat("mopcrt",this, "chemical/x-mopac-input");
  516|      2|      OBConversion::RegisterFormat("mop",this, "chemical/x-mopac-input");
  517|      2|      OBConversion::RegisterFormat("mpc",this, "chemical/x-mopac-input");
  518|       |      // Command-line keywords
  519|      2|      OBConversion::RegisterOptionParam("k", nullptr, 1, OBConversion::OUTOPTIONS);
  520|       |      // Command-line keyword file
  521|      2|      OBConversion::RegisterOptionParam("f", nullptr, 1, OBConversion::OUTOPTIONS);
  522|      2|    }
_ZN9OpenBabel14MOPACINTFormatC2Ev:
  849|      2|    {
  850|      2|      OBConversion::RegisterFormat("mopin", this, "chemical/x-mopac-input");
  851|       |      // Command-line keywords
  852|      2|      OBConversion::RegisterOptionParam("k", nullptr, 1, OBConversion::OUTOPTIONS);
  853|       |      // Command-line keyword file
  854|      2|      OBConversion::RegisterOptionParam("f", nullptr, 1, OBConversion::OUTOPTIONS);
  855|      2|    }
_ZN9OpenBabel11MOPACFormat5FlagsEv:
   51|      4|    {
   52|      4|      return NOTWRITABLE;
  ------------------
  |  |   35|      4|#define NOTWRITABLE     0x10
  ------------------
   53|      4|    }

_ZN9OpenBabel9MPDFormatC2Ev:
   44|      2|    {
   45|      2|      OBConversion::RegisterFormat("mpd",this);
   46|      2|      OBConversion::RegisterOptionParam("n", this);
   47|      2|      OBConversion::RegisterOptionParam("c", this);
   48|      2|      OBConversion::RegisterOptionParam("i", this);
   49|      2|    }
_ZN9OpenBabel9MPDFormat5FlagsEv:
   84|      2|    {                            // NOTREADABLE  READONEONLY  NOTWRITABLE  WRITEONEONLY
   85|      2|      return NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
   86|      2|    }

_ZN9OpenBabel10MPQCFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
  106|      1|  {
  107|       |
  108|      1|    OBMol* pmol = pOb->CastAndClear<OBMol>();
  109|      1|    if (pmol == nullptr)
  ------------------
  |  Branch (109:9): [True: 0, False: 1]
  ------------------
  110|      0|      return false;
  111|       |
  112|       |    //Define some references so we can use the old parameter names
  113|      1|    istream &ifs = *pConv->GetInStream();
  114|      1|    OBMol &mol = *pmol;
  115|      1|    const char* title = pConv->GetTitle();
  116|       |
  117|      1|    char buffer[BUFF_SIZE];
  118|      1|    string str,str1;
  119|      1|    double x,y,z;
  120|      1|    OBAtom *atom;
  121|      1|    vector<string> vs;
  122|      1|    bool bohr = true;
  123|       |
  124|      1|    mol.BeginModify();
  125|      2|    while	(ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      2|#define BUFF_SIZE 32768
  ------------------
  |  Branch (125:12): [True: 1, False: 1]
  ------------------
  126|      1|      {
  127|      1|        if (strstr(buffer, "<Molecule>:") != nullptr)
  ------------------
  |  Branch (127:13): [True: 0, False: 1]
  ------------------
  128|      0|          {
  129|       |            // mol.EndModify();
  130|      0|            mol.Clear();
  131|      0|            while (strstr(buffer, "geometry") == nullptr)
  ------------------
  |  Branch (131:20): [True: 0, False: 0]
  ------------------
  132|      0|              {
  133|      0|                if (strstr(buffer, "angstrom") != nullptr)
  ------------------
  |  Branch (133:21): [True: 0, False: 0]
  ------------------
  134|      0|                  bohr = false;
  135|      0|                if (!ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (135:21): [True: 0, False: 0]
  ------------------
  136|      0|                  return(false);
  137|      0|              }
  138|      0|            ifs.getline(buffer,BUFF_SIZE); // Now we're on the atoms
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  139|      0|            tokenize(vs,buffer);
  140|      0|            while (vs.size() == 6)
  ------------------
  |  Branch (140:20): [True: 0, False: 0]
  ------------------
  141|      0|              {
  142|      0|                if (bohr)
  ------------------
  |  Branch (142:21): [True: 0, False: 0]
  ------------------
  143|      0|                  {
  144|      0|                    x = atof((char*)vs[3].c_str()) * BOHR_TO_ANGSTROM;
  ------------------
  |  |   27|      0|#define BOHR_TO_ANGSTROM 0.529177249
  ------------------
  145|      0|                    y = atof((char*)vs[4].c_str()) * BOHR_TO_ANGSTROM;
  ------------------
  |  |   27|      0|#define BOHR_TO_ANGSTROM 0.529177249
  ------------------
  146|      0|                    z = atof((char*)vs[5].c_str()) * BOHR_TO_ANGSTROM;
  ------------------
  |  |   27|      0|#define BOHR_TO_ANGSTROM 0.529177249
  ------------------
  147|      0|                  }
  148|      0|                else
  149|      0|                  {
  150|      0|                    x = atof((char*)vs[3].c_str());
  151|      0|                    y = atof((char*)vs[4].c_str());
  152|      0|                    z = atof((char*)vs[5].c_str());
  153|      0|                  }
  154|      0|                atom = mol.NewAtom();
  155|      0|                atom->SetVector(x,y,z);
  156|      0|                atom->SetAtomicNum(OBElements::GetAtomicNum(vs[1].c_str()));
  157|       |
  158|      0|                if (!ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (158:21): [True: 0, False: 0]
  ------------------
  159|      0|                  break;
  160|      0|                tokenize(vs,buffer);
  161|      0|              }
  162|      0|          }
  163|      1|      }
  164|       |
  165|      1|    if (mol.NumAtoms() == 0) { // e.g., if we're at the end of a file PR#1737209
  ------------------
  |  Branch (165:9): [True: 1, False: 0]
  ------------------
  166|      1|      mol.EndModify();
  167|      1|      return false;
  168|      1|    }
  169|       |
  170|      0|    if (!pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (170:9): [True: 0, False: 0]
  ------------------
  171|      0|      mol.ConnectTheDots();
  172|      0|    if (!pConv->IsOption("s",OBConversion::INOPTIONS) && !pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (172:9): [True: 0, False: 0]
  |  Branch (172:58): [True: 0, False: 0]
  ------------------
  173|      0|      mol.PerceiveBondOrders();
  174|       |
  175|      0|    mol.EndModify();
  176|       |
  177|      0|    mol.SetTitle(title);
  178|       |
  179|      0|    return(true);
  180|      1|  }
_ZN9OpenBabel10MPQCFormatC2Ev:
   34|      2|    {
   35|      2|      OBConversion::RegisterFormat("mpqc",this);
   36|      2|    }
_ZN9OpenBabel15MPQCInputFormatC2Ev:
   73|      2|    {
   74|      2|      OBConversion::RegisterFormat("mpqcin",this);
   75|      2|    }
_ZN9OpenBabel10MPQCFormat5FlagsEv:
   54|      5|    {
   55|      5|      return NOTWRITABLE | READONEONLY;
  ------------------
  |  |   35|      5|#define NOTWRITABLE     0x10
  ------------------
                    return NOTWRITABLE | READONEONLY;
  ------------------
  |  |   32|      5|#define READONEONLY     0x02
  ------------------
   56|      5|    }
_ZN9OpenBabel15MPQCInputFormat5FlagsEv:
   91|      2|    {
   92|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   93|      2|    }

_ZN9OpenBabel9MSIFormatC2Ev:
   34|      2|    {
   35|      2|      OBConversion::RegisterFormat("msi", this, "chemical/x-msi-msi");
   36|      2|    }
_ZN9OpenBabel9MSIFormat5FlagsEv:
   54|      2|    {
   55|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   56|      2|    }

_ZN9OpenBabel12OBMSMSFormatC2Ev:
   55|      2|    {
   56|      2|        OpenBabel::OBConversion::RegisterFormat( "msms", this );
   57|      2|    }
_ZN9OpenBabel12OBMSMSFormat5FlagsEv:
   81|      2|    {
   82|      2|        return WRITEONEONLY | NOTREADABLE;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
                      return WRITEONEONLY | NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
   83|      2|    }

_ZN9OpenBabel9NulFormatC2Ev:
   23|      2|  NulFormat() { OBConversion::RegisterFormat("nul",this); }
_ZN9OpenBabel9NulFormat5FlagsEv:
   27|      2|  unsigned int Flags() override { return NOTREADABLE; }
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------

_ZN9OpenBabel18NWChemOutputFormatC2Ev:
   43|      2|    {
   44|      2|      OBConversion::RegisterFormat("nwo",this);
   45|      2|    }
_ZN9OpenBabel17NWChemInputFormatC2Ev:
  136|      2|    {
  137|      2|      OBConversion::RegisterFormat("nw",this);
  138|      2|    }
_ZN9OpenBabel18NWChemOutputFormat5FlagsEv:
   66|      2|    {
   67|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   68|      2|    }
_ZN9OpenBabel17NWChemInputFormat5FlagsEv:
  153|      2|    {
  154|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
  155|      2|    }

_ZN9OpenBabel18OBOpenDXCubeFormatC2Ev:
   45|      2|    {
   46|      2|        OpenBabel::OBConversion::RegisterFormat( "dx", this );
   47|      2|    }
_ZN9OpenBabel18OBOpenDXCubeFormat5FlagsEv:
   73|      2|    {
   74|      2|      return READONEONLY | WRITEONEONLY | ZEROATOMSOK;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY | ZEROATOMSOK;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
                    return READONEONLY | WRITEONEONLY | ZEROATOMSOK;
  ------------------
  |  |   34|      2|#define ZEROATOMSOK     0x08
  ------------------
   75|      2|    }

_ZN9OpenBabel12OutputFormatC2Ev:
   37|      2|    {
   38|      2|      OBConversion::RegisterFormat("out", this);
   39|      2|      OBConversion::RegisterFormat("output", this);
   40|      2|      OBConversion::RegisterFormat("log", this);
   41|      2|      OBConversion::RegisterFormat("dat", this);
   42|      2|    }
_ZN9OpenBabel12OutputFormat5FlagsEv:
   63|      8|    {
   64|      8|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      8|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      8|#define NOTWRITABLE     0x10
  ------------------
   65|      8|    }

_ZN9OpenBabel13PCModelFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("pcm", this);
   37|      2|    }

_ZN9OpenBabel9PDBFormatC2Ev:
   42|      2|    { 
   43|      2|      OBConversion::RegisterFormat("pdb",this, "chemical/x-pdb");
   44|      2|      OBConversion::RegisterFormat("ent",this, "chemical/x-pdb");
   45|       |
   46|      2|      OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS);
   47|      2|      OBConversion::RegisterOptionParam("b", this, 0, OBConversion::INOPTIONS);
   48|      2|      OBConversion::RegisterOptionParam("c", this, 0, OBConversion::INOPTIONS);
   49|       |
   50|      2|      OBConversion::RegisterOptionParam("o", this, 0, OBConversion::OUTOPTIONS);
   51|      2|      OBConversion::RegisterOptionParam("n", this, 0, OBConversion::OUTOPTIONS);
   52|      2|    }

_ZN9OpenBabel11PDBQTFormatC2Ev:
   73|      2|    {
   74|      2|      OBConversion::RegisterFormat("pdbqt",this, "chemical/x-pdbqt");
   75|      2|    }

_ZN9OpenBabel16PointCloudFormatC2Ev:
   62|      2|      {
   63|      2|        OpenBabel::OBConversion::RegisterFormat( "pointcloud", this );
   64|       |        /*
   65|       |        OBConversion::RegisterOptionParam("r", this, 1, OBConversion::OUTOPTIONS);
   66|       |        OBConversion::RegisterOptionParam("d", this, 1, OBConversion::OUTOPTIONS);
   67|       |        OBConversion::RegisterOptionParam("p", this, 1, OBConversion::OUTOPTIONS);
   68|       |        OBConversion::RegisterOptionParam("x", this, 1, OBConversion::OUTOPTIONS);
   69|       |        */
   70|      2|      }
_ZN9OpenBabel16PointCloudFormat5FlagsEv:
  108|      2|      {
  109|      2|        return WRITEONEONLY | NOTREADABLE;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
                      return WRITEONEONLY | NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
  110|      2|      }

_ZN9OpenBabel12PovrayFormatC2Ev:
  105|      2|    {
  106|      2|      OBConversion::RegisterFormat("pov",this);
  107|      2|    }
_ZN9OpenBabel12PovrayFormat5FlagsEv:
  151|      2|    {
  152|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
  153|      2|    }

_ZN9OpenBabel9PQRFormatC2Ev:
   41|      2|    {
   42|      2|      OBConversion::RegisterFormat("pqr",this, "chemical/x-pqr");
   43|      2|    }

_ZN9OpenBabel11PWscfFormatC2Ev:
   38|      2|    {
   39|      2|      OBConversion::RegisterFormat("pwscf",this);
   40|      2|    }
_ZN9OpenBabel11PWscfFormat5FlagsEv:
   57|      2|    {
   58|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   59|      2|    }

_ZN9OpenBabel17QChemOutputFormatC2Ev:
   36|      2|    {
   37|      2|      OBConversion::RegisterFormat("qcout",this);
   38|      2|    }
_ZN9OpenBabel16QChemInputFormatC2Ev:
   73|      2|    {
   74|      2|      OBConversion::RegisterFormat("qcin",this);
   75|      2|    }
_ZN9OpenBabel17QChemOutputFormat5FlagsEv:
   55|      2|    {
   56|      2|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
   57|      2|    }
_ZN9OpenBabel16QChemInputFormat5FlagsEv:
   92|      2|    {
   93|      2|      return WRITEONEONLY | NOTREADABLE;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
                    return WRITEONEONLY | NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
   94|      2|    }

_ZN9OpenBabel12ReportFormatC2Ev:
   40|      2|    {
   41|      2|      OBConversion::RegisterFormat("report",this);
   42|      2|    }
_ZN9OpenBabel12ReportFormat5FlagsEv:
  174|      2|    {
  175|      2|      return NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
  176|      2|    }

_ZN9OpenBabel14SmiReactFormatC2Ev:
   36|      2|    {
   37|      2|      OBConversion::RegisterFormat("rsmi",this);
   38|      2|    }

_ZN9OpenBabel9RXNFormatC2Ev:
   39|      2|  {
   40|      2|      OBConversion::RegisterFormat("rxn",this);
   41|      2|  }

_ZN9OpenBabel11ShelXFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("res",this, "chemical/x-shelx");
   37|      2|      OBConversion::RegisterFormat("ins",this, "chemical/x-shelx");
   38|      2|    }
_ZN9OpenBabel11ShelXFormat5FlagsEv:
   59|      4|    {
   60|      4|      return NOTWRITABLE;
  ------------------
  |  |   35|      4|#define NOTWRITABLE     0x10
  ------------------
   61|      4|    }

_ZN9OpenBabel9SMIFormatC2Ev:
  119|      2|    {
  120|      2|      OBConversion::RegisterFormat("smi",this, "chemical/x-daylight-smiles");
  121|      2|      OBConversion::RegisterFormat("smiles",this, "chemical/x-daylight-smiles");
  122|      2|      OBConversion::RegisterOptionParam("n", this);
  123|      2|      OBConversion::RegisterOptionParam("t", this);
  124|      2|      OBConversion::RegisterOptionParam("r", this);
  125|      2|      OBConversion::RegisterOptionParam("a", this);
  126|      2|      OBConversion::RegisterOptionParam("h", this);
  127|      2|      OBConversion::RegisterOptionParam("x", this);
  128|      2|      OBConversion::RegisterOptionParam("C", this);	// "anti-canonical" form (random order)
  129|      2|    }
_ZN9OpenBabel12CANSMIFormatC2Ev:
  212|      2|    {
  213|      2|      OBConversion::RegisterFormat("can", this, "chemical/x-daylight-cansmiles");
  214|      2|    }
_ZN9OpenBabel9FIXFormatC2Ev:
 4286|      2|    {
 4287|      2|      OBConversion::RegisterFormat("fix",this);
 4288|      2|    }
_ZN9OpenBabel9FIXFormat5FlagsEv:
 4303|      2|    {
 4304|      2|      return NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
 4305|      2|    }

_ZN9OpenBabel9STLFormatC2Ev:
  110|      2|      {
  111|      2|        OpenBabel::OBConversion::RegisterFormat( "stl", this );
  112|       |        /*
  113|       |        OBConversion::RegisterOptionParam("p", this, 1, OBConversion::OUTOPTIONS);
  114|       |        OBConversion::RegisterOptionParam("s", this, 1, OBConversion::OUTOPTIONS);
  115|       |        OBConversion::RegisterOptionParam("c", this, 1, OBConversion::OUTOPTIONS);
  116|       |        */
  117|      2|        OBConversion::RegisterOptionParam("bond-size", this, 1, OBConversion::GENOPTIONS);
  118|      2|        OBConversion::RegisterOptionParam("bond-radius", this, 1, OBConversion::GENOPTIONS);
  119|      2|        OBConversion::RegisterOptionParam("colour-order-rgb", this, 0, OBConversion::GENOPTIONS);
  120|      2|      }
_ZN9OpenBabel9STLFormat5FlagsEv:
  149|      2|      {
  150|      2|        return WRITEONEONLY | NOTREADABLE;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
                      return WRITEONEONLY | NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
  151|      2|      }

_ZN9OpenBabel9SVGFormatC2Ev:
   32|      2|  SVGFormat() : _ncols(0), _nrows(0), _nmax(0)
   33|      2|  {
   34|      2|    OBConversion::RegisterFormat("svg",this);
   35|      2|    OBConversion::RegisterOptionParam("N", this, 1, OBConversion::OUTOPTIONS);
   36|      2|    OBConversion::RegisterOptionParam("rows", this, 1, OBConversion::GENOPTIONS);
   37|      2|    OBConversion::RegisterOptionParam("cols", this, 1, OBConversion::GENOPTIONS);
   38|      2|    OBConversion::RegisterOptionParam("px", this, 1, OBConversion::GENOPTIONS);
   39|      2| }
_ZN9OpenBabel9SVGFormat5FlagsEv:
  157|      2|  {
  158|      2|      return NOTREADABLE | ZEROATOMSOK | DEPICTION2D;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | ZEROATOMSOK | DEPICTION2D;
  ------------------
  |  |   34|      2|#define ZEROATOMSOK     0x08
  ------------------
                    return NOTREADABLE | ZEROATOMSOK | DEPICTION2D;
  ------------------
  |  |   39|      2|#define DEPICTION2D     0x100
  ------------------
  159|      2|  }

_ZN9OpenBabel10TextFormatC2Ev:
   25|      2|  {
   26|      2|    OBConversion::RegisterFormat("text",this);
   27|      2|  }

_ZN9OpenBabel12ThermoFormatC2Ev:
   38|      2|  {
   39|      2|      OBConversion::RegisterFormat("therm",this);
   40|      2|      OBConversion::RegisterFormat("tdd",this);
   41|      2|  }

_ZN9OpenBabel12TinkerFormatC2Ev:
   38|      2|    {
   39|      2|      OBConversion::RegisterFormat("txyz",this);
   40|      2|    }
_ZN9OpenBabel12TinkerFormat5FlagsEv:
   65|      2|    {
   66|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   67|      2|    }

_ZN9OpenBabel11TitleFormatC2Ev:
   29|      2|  {
   30|      2|      OBConversion::RegisterFormat("txt",this);
   31|      2|  }
_ZN9OpenBabel11TitleFormat5FlagsEv:
   39|      2|  unsigned int Flags() override { return ZEROATOMSOK; }
  ------------------
  |  |   34|      2|#define ZEROATOMSOK     0x08
  ------------------

_ZN9OpenBabel15TurbomoleFormatC2Ev:
   38|      2|    {
   39|      2|      OBConversion::RegisterFormat("tmol",this);
   40|      2|      OBConversion::RegisterOptionParam("a", this, OBConversion::INOPTIONS);
   41|      2|    }
_ZN9OpenBabel15TurbomoleFormat5FlagsEv:
   62|      2|    {
   63|      2|        return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   64|      2|    }

_ZN9OpenBabel13UniChemFormatC2Ev:
   33|      2|    {
   34|      2|        OBConversion::RegisterFormat("unixyz",this);
   35|      2|    }
_ZN9OpenBabel13UniChemFormat5FlagsEv:
   52|      2|    {
   53|      2|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   54|      2|    }

_ZN9OpenBabel10VASPFormatC2Ev:
   65|      2|    {
   66|       |      // This will actually read the CONTCAR file:
   67|      2|      OBConversion::RegisterFormat("CONTCAR",this);
   68|      2|      OBConversion::RegisterFormat("POSCAR",this);
   69|      2|      OBConversion::RegisterFormat("VASP",this);
   70|      2|      OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS);
   71|      2|      OBConversion::RegisterOptionParam("b", this, 0, OBConversion::INOPTIONS);
   72|      2|      OBConversion::RegisterOptionParam("w", this, 0, OBConversion::OUTOPTIONS);
   73|      2|      OBConversion::RegisterOptionParam("z", this, 0, OBConversion::OUTOPTIONS);
   74|      2|      OBConversion::RegisterOptionParam("4", this, 0, OBConversion::OUTOPTIONS);
   75|      2|    }
_ZN9OpenBabel10VASPFormat5FlagsEv:
  122|      6|    {
  123|      6|      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      6|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      6|#define WRITEONEONLY    0x20
  ------------------
  124|      6|    }

_ZN9OpenBabel13ViewMolFormatC2Ev:
   32|      2|  {
   33|      2|    OBConversion::RegisterFormat("vmol",this);
   34|      2|  }
_ZN9OpenBabel13ViewMolFormat5FlagsEv:
   51|      2|    {
   52|      2|        return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                      return READONEONLY | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   53|      2|    }

_ZN9OpenBabel9XEDFormatC2Ev:
   35|      2|    {
   36|      2|        OBConversion::RegisterFormat("xed",this);
   37|      2|    }
_ZN9OpenBabel9XEDFormat5FlagsEv:
   52|      2|    {
   53|      2|        return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   54|      2|    }

_ZN9OpenBabel9XSFFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("xsf",this);
   37|       |      // animation variant
   38|      2|      OBConversion::RegisterFormat("axsf",this);
   39|      2|    }
_ZN9OpenBabel9XSFFormat5FlagsEv:
   57|      4|    {
   58|      4|      return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   32|      4|#define READONEONLY     0x02
  ------------------
                    return READONEONLY | NOTWRITABLE;
  ------------------
  |  |   35|      4|#define NOTWRITABLE     0x10
  ------------------
   59|      4|    }

_ZN9OpenBabel9XYZFormatC2Ev:
   35|      2|    {
   36|      2|      OBConversion::RegisterFormat("xyz", this, "chemical/x-xyz");
   37|      2|    }

_ZN9OpenBabel9YOBFormatC2Ev:
  320|      2|    {
  321|      2|        OBConversion::RegisterFormat("yob",this);
  322|      2|    }
_ZN9OpenBabel9YOBFormat5FlagsEv:
  337|      2|    {
  338|      2|        return READONEONLY|READBINARY|WRITEBINARY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
                      return READONEONLY|READBINARY|WRITEBINARY;
  ------------------
  |  |   33|      2|#define READBINARY      0x04
  ------------------
                      return READONEONLY|READBINARY|WRITEBINARY;
  ------------------
  |  |   37|      2|#define WRITEBINARY     0x40
  ------------------
  339|      2|    }

_ZN9OpenBabel11ZINDOFormatC2Ev:
   33|      2|    {
   34|      2|      OBConversion::RegisterFormat("zin",this);
   35|      2|    }
_ZN9OpenBabel11ZINDOFormat5FlagsEv:
   52|      2|    {
   53|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
   54|      2|    }

_ZN9OpenBabel8OBLocaleC2Ev:
   80|      2|  {
   81|      2|    d = new OBLocalePrivate;
   82|      2|  }
_ZN9OpenBabel15OBLocalePrivateC2Ev:
   41|      2|    OBLocalePrivate(): counter(0)
   42|      2|    {
   43|       |#if HAVE_USELOCALE
   44|       |      new_c_num_locale = newlocale(LC_NUMERIC_MASK, NULL, NULL);
   45|       |#endif
   46|      2|    }

_ZN9OpenBabel11SpaceGroupsC2Ev:
   69|      2|  {
   70|      2|    sgbi.assign(230, list<const SpaceGroup*>());
   71|      2|    _dir = BABEL_DATADIR;
  ------------------
  |  |    4|      2|#define BABEL_DATADIR "/usr/local/share/openbabel"
  ------------------
   72|      2|    _envvar = "BABEL_DATADIR";
   73|      2|    _filename = "space-groups.txt";
   74|      2|    _subdir = "data";
   75|      2|    _dataptr = SpaceGroupsData;
   76|      2|  }

_ZN9OpenBabel5OBMol8SetTitleEPKc:
  172|      2|  {
  173|      2|    _title = title;
  174|      2|    Trim(_title);
  175|      2|  }
_ZN9OpenBabel5OBMol8SetTitleERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  178|      4|  {
  179|      4|    _title = title;
  180|      4|    Trim(_title);
  181|      4|  }
_ZN9OpenBabel5OBMol5ClearEv:
 1455|      6|  {
 1456|      6|    if (obErrorLog.GetOutputLevel() >= obAuditMsg)
  ------------------
  |  Branch (1456:9): [True: 0, False: 6]
  ------------------
 1457|      0|      obErrorLog.ThrowError(__FUNCTION__,
 1458|      0|                            "Ran OpenBabel::Clear Molecule", obAuditMsg);
 1459|       |
 1460|       |    // Destroy residues first: ~OBResidue() walks its atom list to clear
 1461|       |    // back-pointers via SetResidue(nullptr). If atoms were destroyed
 1462|       |    // first, those calls would dereference dead pointers (UBSAN trips
 1463|       |    // in residue.cpp:853). The symmetric path in ~OBAtom() already
 1464|       |    // handles the reverse direction by checking _residue != nullptr.
 1465|      6|    unsigned int ii;
 1466|      6|    for (ii=0 ; ii<_residue.size() ; ++ii)
  ------------------
  |  Branch (1466:17): [True: 0, False: 6]
  ------------------
 1467|      0|      {
 1468|      0|        DestroyResidue(_residue[ii]);
 1469|      0|      }
 1470|      6|    _residue.clear();
 1471|       |
 1472|      6|    vector<OBAtom*>::iterator i;
 1473|      6|    vector<OBBond*>::iterator j;
 1474|      6|    for (i = _vatom.begin();i != _vatom.end();++i)
  ------------------
  |  Branch (1474:29): [True: 0, False: 6]
  ------------------
 1475|      0|      {
 1476|      0|        DestroyAtom(*i);
 1477|      0|        *i = nullptr;
 1478|      0|      }
 1479|      6|    for (j = _vbond.begin();j != _vbond.end();++j)
  ------------------
  |  Branch (1479:29): [True: 0, False: 6]
  ------------------
 1480|      0|      {
 1481|      0|        DestroyBond(*j);
 1482|      0|        *j = nullptr;
 1483|      0|      }
 1484|       |
 1485|      6|    _atomIds.clear();
 1486|      6|    _bondIds.clear();
 1487|      6|    _natoms = _nbonds = 0;
 1488|       |
 1489|       |    //clear out the multiconformer data
 1490|      6|    vector<double*>::iterator k;
 1491|      6|    for (k = _vconf.begin();k != _vconf.end();++k)
  ------------------
  |  Branch (1491:29): [True: 0, False: 6]
  ------------------
 1492|      0|      delete [] *k;
 1493|      6|    _vconf.clear();
 1494|       |
 1495|       |    //Clear flags except OB_PATTERN_STRUCTURE which is left the same
 1496|      6|    _flags &= OB_PATTERN_STRUCTURE;
  ------------------
  |  |  101|      6|#define OB_PATTERN_STRUCTURE     (1<<19)
  ------------------
 1497|       |
 1498|      6|    _c = nullptr;
 1499|      6|    _mod = 0;
 1500|       |
 1501|       |    // Clean up generic data via the base class
 1502|      6|    return(OBBase::Clear());
 1503|      6|  }
_ZN9OpenBabel5OBMol11BeginModifyEv:
 1506|      5|  {
 1507|       |    //suck coordinates from _c into _v for each atom
 1508|      5|    if (!_mod && !Empty())
  ------------------
  |  Branch (1508:9): [True: 5, False: 0]
  |  Branch (1508:18): [True: 0, False: 5]
  ------------------
 1509|      0|      {
 1510|      0|        OBAtom *atom;
 1511|      0|        vector<OBAtom*>::iterator i;
 1512|      0|        for (atom = BeginAtom(i);atom;atom = NextAtom(i))
  ------------------
  |  Branch (1512:34): [True: 0, False: 0]
  ------------------
 1513|      0|          {
 1514|      0|            atom->SetVector();
 1515|      0|            atom->ClearCoordPtr();
 1516|      0|          }
 1517|       |
 1518|      0|        vector<double*>::iterator j;
 1519|      0|        for (j = _vconf.begin();j != _vconf.end();++j)
  ------------------
  |  Branch (1519:33): [True: 0, False: 0]
  ------------------
 1520|      0|          delete [] *j;
 1521|       |
 1522|      0|        _c = nullptr;
 1523|      0|        _vconf.clear();
 1524|       |
 1525|       |        //Destroy rotamer list if necessary
 1526|      0|        if ((OBRotamerList *)GetData(OBGenericDataType::RotamerList))
  ------------------
  |  Branch (1526:13): [True: 0, False: 0]
  ------------------
 1527|      0|          {
 1528|      0|            delete (OBRotamerList *)GetData(OBGenericDataType::RotamerList);
 1529|      0|            DeleteData(OBGenericDataType::RotamerList);
 1530|      0|          }
 1531|      0|      }
 1532|       |
 1533|      5|    _mod++;
 1534|      5|  }
_ZN9OpenBabel5OBMol9EndModifyEb:
 1537|      5|  {
 1538|      5|    if (_mod == 0)
  ------------------
  |  Branch (1538:9): [True: 0, False: 5]
  ------------------
 1539|      0|      {
 1540|      0|        obErrorLog.ThrowError(__FUNCTION__, "_mod is negative - EndModify() called too many times", obDebug);
 1541|      0|        return;
 1542|      0|      }
 1543|       |
 1544|      5|    _mod--;
 1545|       |
 1546|      5|    if (_mod)
  ------------------
  |  Branch (1546:9): [True: 0, False: 5]
  ------------------
 1547|      0|      return;
 1548|       |
 1549|       |    // wipe all but whether it has aromaticity perceived, is a reaction, or has periodic boundaries enabled
 1550|      5|    if (nukePerceivedData)
  ------------------
  |  Branch (1550:9): [True: 5, False: 0]
  ------------------
 1551|      5|      _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL);
  ------------------
  |  |   77|      5|#define OB_AROMATIC_MOL          (1<<3)
  ------------------
                    _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL);
  ------------------
  |  |  107|      5|#define OB_REACTION_MOL          (1<<22)
  ------------------
                    _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL);
  ------------------
  |  |  109|      5|#define OB_PERIODIC_MOL          (1<<23)
  ------------------
 1552|       |
 1553|      5|    _c = nullptr;
 1554|       |
 1555|      5|    if (Empty())
  ------------------
  |  Branch (1555:9): [True: 5, False: 0]
  ------------------
 1556|      5|      return;
 1557|       |
 1558|       |    //if atoms present convert coords into array
 1559|      0|    double *c = new double [NumAtoms()*3];
 1560|      0|    _c = c;
 1561|       |
 1562|      0|    unsigned int idx;
 1563|      0|    OBAtom *atom;
 1564|      0|    vector<OBAtom*>::iterator j;
 1565|      0|    for (idx=0,atom = BeginAtom(j);atom;atom = NextAtom(j),++idx)
  ------------------
  |  Branch (1565:36): [True: 0, False: 0]
  ------------------
 1566|      0|      {
 1567|      0|        atom->SetIdx(idx+1);
 1568|      0|        (atom->GetVector()).Get(&_c[idx*3]);
 1569|      0|        atom->SetCoordPtr(&_c);
 1570|      0|      }
 1571|      0|    _vconf.push_back(c);
 1572|       |
 1573|       |    // Always remove angle and torsion data, since they will interfere with the iterators
 1574|       |    // PR#2812013
 1575|      0|    DeleteData(OBGenericDataType::AngleData);
 1576|      0|    DeleteData(OBGenericDataType::TorsionData);
 1577|      0|  }
_ZN9OpenBabel5OBMolC2Ev:
 2755|     20|  {
 2756|     20|    _natoms = _nbonds = 0;
 2757|     20|    _mod = 0;
 2758|     20|    _totalCharge = 0;
 2759|     20|    _dimension = 3;
 2760|     20|    _vatom.clear();
 2761|     20|    _atomIds.clear();
 2762|     20|    _vbond.clear();
 2763|     20|    _bondIds.clear();
 2764|     20|    _vdata.clear();
 2765|     20|    _title = "";
 2766|     20|    _c = nullptr;
 2767|     20|    _flags = 0;
 2768|     20|    _vconf.clear();
 2769|     20|    _autoPartialCharge = true;
 2770|     20|    _autoFormalCharge = true;
 2771|     20|    _energy = 0.0;
 2772|     20|  }
_ZN9OpenBabel5OBMolD2Ev:
 2797|      8|  {
 2798|      8|    OBAtom    *atom;
 2799|      8|    OBBond    *bond;
 2800|      8|    OBResidue *residue;
 2801|      8|    vector<OBAtom*>::iterator i;
 2802|      8|    vector<OBBond*>::iterator j;
 2803|      8|    vector<OBResidue*>::iterator r;
 2804|       |    // Destroy residues before atoms so ~OBResidue() can clear back-
 2805|       |    // pointers on still-live atoms (see Clear() for the same reason).
 2806|      8|    for (residue = BeginResidue(r);residue;residue = NextResidue(r))
  ------------------
  |  Branch (2806:36): [True: 0, False: 8]
  ------------------
 2807|      0|      DestroyResidue(residue);
 2808|      8|    for (atom = BeginAtom(i);atom;atom = NextAtom(i))
  ------------------
  |  Branch (2808:30): [True: 0, False: 8]
  ------------------
 2809|      0|      DestroyAtom(atom);
 2810|      8|    for (bond = BeginBond(j);bond;bond = NextBond(j))
  ------------------
  |  Branch (2810:30): [True: 0, False: 8]
  ------------------
 2811|      0|      DestroyBond(bond);
 2812|       |
 2813|       |    //clear out the multiconformer data
 2814|      8|    vector<double*>::iterator k;
 2815|      8|    for (k = _vconf.begin();k != _vconf.end();++k)
  ------------------
  |  Branch (2815:29): [True: 0, False: 8]
  ------------------
 2816|      0|      delete [] *k;
 2817|      8|    _vconf.clear();
 2818|      8|  }
_ZN9OpenBabel5OBMol9BeginAtomERNSt3__111__wrap_iterIPPNS_6OBAtomEEE:
 3994|      8|  {
 3995|      8|    i = _vatom.begin();
 3996|      8|    return i == _vatom.end() ? nullptr : (OBAtom*)*i;
  ------------------
  |  Branch (3996:12): [True: 8, False: 0]
  ------------------
 3997|      8|  }
_ZN9OpenBabel5OBMol9BeginBondERNSt3__111__wrap_iterIPPNS_6OBBondEEE:
 4018|      8|  {
 4019|      8|    i = _vbond.begin();
 4020|      8|    return i == _vbond.end() ? nullptr : (OBBond*)*i;
  ------------------
  |  Branch (4020:12): [True: 8, False: 0]
  ------------------
 4021|      8|  }

_ZN9OpenBabel12OBConversionC2EPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEEPNS1_13basic_ostreamIcS4_EE:
  232|      8|    pInput(nullptr), pOutput(nullptr),
  233|      8|    pInFormat(nullptr),pOutFormat(nullptr), Index(0), StartNumber(1),
  234|      8|    EndNumber(0), Count(-1), m_IsFirstInput(true), m_IsLast(true),
  235|      8|    MoreFilesToCome(false), OneObjectOnly(false), ReadyToInput(false), SkippedMolecules(false),
  236|      8|    inFormatGzip(false), outFormatGzip(false),
  237|      8|    pOb1(nullptr), wInpos(0), wInlen(0), pAuxConv(nullptr)
  238|      8|  {
  239|      8|   	SetInStream(is);
  240|      8|   	SetOutStream(os);
  241|       |
  242|       |    //These options take a parameter
  243|      8|    RegisterOptionParam("f", nullptr, 1,GENOPTIONS);
  244|      8|    RegisterOptionParam("l", nullptr, 1,GENOPTIONS);
  245|      8|  }
_ZN9OpenBabel12OBConversionD2Ev:
  313|      8|  {
  314|      8|    if(pAuxConv!=this)
  ------------------
  |  Branch (314:8): [True: 8, False: 0]
  ------------------
  315|      8|      delete pAuxConv;
  316|       |    // Free any remaining streams from convenience functions
  317|      8|    SetInStream(nullptr);
  318|      8|    SetOutStream(nullptr);
  319|       |
  320|      8|  }
_ZN9OpenBabel12OBConversion14RegisterFormatEPKcPNS_8OBFormatES2_:
  330|    320|  {
  331|    320|    return pFormat->RegisterFormat(ID, MIME);
  332|    320|  }
_ZN9OpenBabel12OBConversion11SetInStreamEPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEEb:
  337|     24|  {
  338|       |      //clear and deallocate any existing streams
  339|     32|      for(unsigned i = 0, n = ownedInStreams.size(); i < n; i++)
  ------------------
  |  Branch (339:54): [True: 8, False: 24]
  ------------------
  340|      8|      {
  341|      8|        delete ownedInStreams[i];
  342|      8|      }
  343|     24|      ownedInStreams.clear();
  344|     24|      pInput = nullptr;
  345|       |
  346|     24|      if (pIn)
  ------------------
  |  Branch (346:11): [True: 8, False: 16]
  ------------------
  347|      8|      {
  348|      8|          if(takeOwnership)
  ------------------
  |  Branch (348:14): [True: 0, False: 8]
  ------------------
  349|      0|              ownedInStreams.push_back(pIn);
  350|      8|          pInput = pIn; //simplest case
  351|       |
  352|       |  #ifdef HAVE_LIBZ
  353|       |          if(IsOption("zin", GENOPTIONS) || inFormatGzip)
  354|       |          {
  355|       |            zlib_stream::zip_istream *zIn = new zlib_stream::zip_istream(*pInput);
  356|       |            ownedInStreams.push_back(zIn);
  357|       |            pInput = zIn;
  358|       |          }
  359|       |  #endif
  360|       |          //always transform newlines if input isn't binary/xml
  361|      8|          if(pInFormat && !(pInFormat->Flags() & (READBINARY | READXML)) &&
  ------------------
  |  |   33|      8|#define READBINARY      0x04
  ------------------
                        if(pInFormat && !(pInFormat->Flags() & (READBINARY | READXML)) &&
  ------------------
  |  |   38|      8|#define READXML         0x80
  ------------------
  |  Branch (361:14): [True: 8, False: 0]
  |  Branch (361:27): [True: 8, False: 0]
  ------------------
  362|      8|              pIn != &std::cin) //avoid filtering stdin as well
  ------------------
  |  Branch (362:15): [True: 8, False: 0]
  ------------------
  363|      8|          {
  364|      8|            LEInStream *leIn = new LEInStream(*pInput);
  365|      8|            ownedInStreams.push_back(leIn);
  366|      8|            pInput = leIn;
  367|      8|          }
  368|      8|      }
  369|     24|  }
_ZN9OpenBabel12OBConversion12SetOutStreamEPNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEb:
  377|     24|  {
  378|       |    //clear and deallocate any existing streams
  379|     24|    for (unsigned i = 0, n = ownedOutStreams.size(); i < n; i++)
  ------------------
  |  Branch (379:54): [True: 0, False: 24]
  ------------------
  380|      0|    {
  381|      0|      delete ownedOutStreams[i];
  382|      0|    }
  383|     24|    ownedOutStreams.clear();
  384|     24|    pOutput = nullptr;
  385|       |
  386|     24|    if (pOut)
  ------------------
  |  Branch (386:9): [True: 8, False: 16]
  ------------------
  387|      8|    {
  388|      8|      if (takeOwnership)
  ------------------
  |  Branch (388:11): [True: 0, False: 8]
  ------------------
  389|      0|        ownedOutStreams.push_back(pOut);
  390|      8|      pOutput = pOut;
  391|       |
  392|       |#ifdef HAVE_LIBZ
  393|       |
  394|       |      if (IsOption("z", GENOPTIONS) || outFormatGzip)
  395|       |      {
  396|       |        zlib_stream::zip_ostream *zOut = new zlib_stream::zip_ostream(*pOutput, true);
  397|       |        //we need to delete the zstream _before_ the underlying stream so it can add the footer
  398|       |        ownedOutStreams.insert(ownedOutStreams.begin(),zOut);
  399|       |        pOutput = zOut;
  400|       |      }
  401|       |#endif
  402|      8|    }
  403|     24|  }
_ZN9OpenBabel12OBConversion11SetInFormatEPKcb:
  439|      8|  {
  440|      8|    inFormatGzip = gzip;
  441|      8|    if(inID)
  ------------------
  |  Branch (441:8): [True: 8, False: 0]
  ------------------
  442|      8|      pInFormat = FindFormat(inID);
  443|      8|    return pInFormat && !(pInFormat->Flags() & NOTREADABLE);
  ------------------
  |  |   31|      8|#define NOTREADABLE     0x01
  ------------------
  |  Branch (443:12): [True: 8, False: 0]
  |  Branch (443:25): [True: 6, False: 2]
  ------------------
  444|      8|  }
_ZN9OpenBabel12OBConversion12SetOutFormatEPKcb:
  448|      8|  {
  449|      8|    outFormatGzip = gzip;
  450|      8|    if(outID)
  ------------------
  |  Branch (450:8): [True: 8, False: 0]
  ------------------
  451|      8|      pOutFormat= FindFormat(outID);
  452|      8|    return pOutFormat && !(pOutFormat->Flags() & NOTWRITABLE);
  ------------------
  |  |   35|      8|#define NOTWRITABLE     0x10
  ------------------
  |  Branch (452:12): [True: 8, False: 0]
  |  Branch (452:26): [True: 8, False: 0]
  ------------------
  453|      8|  }
_ZN9OpenBabel12OBConversion7ConvertEPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEEPNS1_13basic_ostreamIcS4_EE:
  459|      8|  {
  460|      8|    StreamState savedIn, savedOut;
  461|      8|    if (is)
  ------------------
  |  Branch (461:9): [True: 8, False: 0]
  ------------------
  462|      8|    {
  463|       |#ifdef HAVE_LIBZ
  464|       |      if(!inFormatGzip && pInFormat && zlib_stream::isGZip(*is))
  465|       |      {
  466|       |        inFormatGzip = true;
  467|       |      }
  468|       |#endif
  469|      8|      savedIn.pushInput(*this);
  470|      8|      SetInStream(is, false);
  471|      8|    }
  472|       |
  473|      8|    if (os)
  ------------------
  |  Branch (473:9): [True: 8, False: 0]
  ------------------
  474|      8|    {
  475|      8|      savedOut.pushOutput(*this);
  476|      8|      SetOutStream(os, false);
  477|      8|    }
  478|       |
  479|      8|    int count = Convert();
  480|       |
  481|      8|    if(savedIn.isSet()) savedIn.popInput(*this);
  ------------------
  |  Branch (481:8): [True: 0, False: 8]
  ------------------
  482|      8|    if(savedOut.isSet()) savedOut.popOutput(*this);
  ------------------
  |  Branch (482:8): [True: 0, False: 8]
  ------------------
  483|       |
  484|      8|    return count;
  485|      8|  }
_ZN9OpenBabel12OBConversion7ConvertEv:
  507|      8|  {
  508|      8|    if (pInput == nullptr)
  ------------------
  |  Branch (508:9): [True: 0, False: 8]
  ------------------
  509|      0|      {
  510|      0|        obErrorLog.ThrowError(__FUNCTION__, "input or output stream not set", obError);
  511|      0|        return 0;
  512|      0|      }
  513|       |
  514|      8|    if(!pInFormat) return 0;
  ------------------
  |  Branch (514:8): [True: 0, False: 8]
  ------------------
  515|      8|    Count=0;//number objects processed
  516|       |
  517|      8|    if(!SetStartAndEnd())
  ------------------
  |  Branch (517:8): [True: 0, False: 8]
  ------------------
  518|      0|      return 0;
  519|       |
  520|      8|    ReadyToInput=true;
  521|      8|    m_IsLast=false;
  522|      8|    pOb1=nullptr;
  523|      8|    wInlen=0;
  524|       |
  525|      8|    if(pInFormat->Flags() & READONEONLY)
  ------------------
  |  |   32|      8|#define READONEONLY     0x02
  ------------------
  |  Branch (525:8): [True: 1, False: 7]
  ------------------
  526|      1|      OneObjectOnly=true;
  527|       |
  528|       |    //Input loop
  529|      8|    while(ReadyToInput && pInput->good()) //Possible to omit? && pInStream->peek() != EOF
  ------------------
  |  Branch (529:11): [True: 8, False: 0]
  |  Branch (529:27): [True: 8, False: 0]
  ------------------
  530|      8|      {
  531|      8|        if(pInput==&cin)
  ------------------
  |  Branch (531:12): [True: 0, False: 8]
  ------------------
  532|      0|          {
  533|      0|            if(pInput->peek()==-1) //Cntl Z Was \n but interfered with piping
  ------------------
  |  Branch (533:16): [True: 0, False: 0]
  ------------------
  534|      0|            {
  535|      0|              if (!IsOption("separate", OBConversion::GENOPTIONS))
  ------------------
  |  Branch (535:19): [True: 0, False: 0]
  ------------------
  536|      0|                break;
  537|      0|              pInput->clear();
  538|      0|            }
  539|      0|          }
  540|      8|        else
  541|      8|          rInpos = pInput->tellg();
  542|      8|        bool ret=false;
  543|      8|#ifndef DONT_CATCH_EXCEPTIONS
  544|      8|       try
  545|      8|#endif
  546|      8|          {
  547|      8|            ret = pInFormat->ReadChemObject(this);
  548|       |/*            if (ret && IsOption("readconformers", GENOPTIONS)) {
  549|       |              std::streampos pos = pInStream->tellg();
  550|       |              OBMol nextMol;
  551|       |              OBConversion conv;
  552|       |              conv.SetOutFormat("smi");
  553|       |              std::string ref_smiles = conv.WriteString(pOb1);
  554|       |              while (pInStream->good()) {
  555|       |                if (!pInFormat->ReadMolecule(&nextMol, this))
  556|       |                  break;
  557|       |                std::string smiles = conv.WriteString(&nextMol);
  558|       |                if (smiles == ref_smiles) {
  559|       |                  OBMol *pmol = dynamic_cast<OBMol*>(pOb1);
  560|       |                  if (!pmol)
  561|       |                    break;
  562|       |                  unsigned int numCoords = nextMol.NumAtoms() * 3;
  563|       |                  double *coords = nextMol.GetCoordinates();
  564|       |                  double *conformer = new double [numCoords];
  565|       |                  for (unsigned int i = 0; i < numCoords; ++i)
  566|       |                    conformer[i] = coords[i];
  567|       |                  pmol->AddConformer(conformer);
  568|       |                  pos = pInStream->tellg();
  569|       |                } else {
  570|       |                  break;
  571|       |                }
  572|       |              }
  573|       |              pInStream->seekg(pos, std::ios::beg);
  574|       |            }
  575|       |*/
  576|      8|            SetFirstInput(false);
  577|      8|          }
  578|      8|#ifndef DONT_CATCH_EXCEPTIONS
  579|      8|        catch(...)
  580|      8|          {
  581|      0|            if(!IsOption("e", GENOPTIONS) && !OneObjectOnly)
  ------------------
  |  Branch (581:16): [True: 0, False: 0]
  |  Branch (581:46): [True: 0, False: 0]
  ------------------
  582|      0|            {
  583|      0|              obErrorLog.ThrowError(__FUNCTION__, "Convert failed with an exception" , obError);
  584|      0|              return Index; // the number we've actually output so far
  585|      0|            }
  586|      0|          }
  587|      0|#endif
  588|       |
  589|      8|        if(!ret)
  ------------------
  |  Branch (589:12): [True: 8, False: 0]
  ------------------
  590|      8|          {
  591|       |            //error or termination request: terminate unless
  592|       |            // -e option requested and successfully can skip past current object
  593|      8|            if(!IsOption("e", GENOPTIONS) || pInFormat->SkipObjects(0,this)!=1)
  ------------------
  |  Branch (593:16): [True: 8, False: 0]
  |  Branch (593:46): [True: 0, False: 0]
  ------------------
  594|      8|              break;
  595|      8|          }
  596|      0|        if(OneObjectOnly)
  ------------------
  |  Branch (596:12): [True: 0, False: 0]
  ------------------
  597|      0|          break;
  598|       |        // Objects supplied to AddChemObject() which may output them after a delay
  599|       |        //ReadyToInput may be made false in AddChemObject()
  600|       |        // by WriteMolecule() returning false  or by Count==EndNumber
  601|      0|      }
  602|       |
  603|       |    //Output last object
  604|      8|    m_IsLast= !MoreFilesToCome;
  605|       |
  606|       |    //Output is always occurs at the end with the --OutputAtEnd option
  607|      8|    bool oae = IsOption("OutputAtEnd", GENOPTIONS) != nullptr;
  608|      8|    if(pOutFormat && (!oae || m_IsLast))
  ------------------
  |  Branch (608:8): [True: 8, False: 0]
  |  Branch (608:23): [True: 8, False: 0]
  |  Branch (608:31): [True: 0, False: 0]
  ------------------
  609|      8|      if((oae || pOb1) && !pOutFormat->WriteChemObject(this))
  ------------------
  |  Branch (609:11): [True: 0, False: 8]
  |  Branch (609:18): [True: 0, False: 8]
  |  Branch (609:27): [True: 0, False: 0]
  ------------------
  610|      0|        Index--;
  611|       |
  612|       |    //Put AddChemObject() into non-queue mode
  613|      8|    Count= -1;
  614|      8|    EndNumber=StartNumber=0; pOb1=nullptr; //leave tidy
  615|      8|    MoreFilesToCome=false;
  616|      8|    OneObjectOnly=false;
  617|       |
  618|      8|    return Index; //The number actually output
  619|      8|  }
_ZN9OpenBabel12OBConversion14SetStartAndEndEv:
  622|      8|  {
  623|      8|    unsigned int TempStartNumber=0;
  624|      8|    const char* p = IsOption("f",GENOPTIONS);
  625|      8|    if(p)
  ------------------
  |  Branch (625:8): [True: 0, False: 8]
  ------------------
  626|      0|      {
  627|      0|        StartNumber=atoi(p);
  628|      0|        if(StartNumber>1)
  ------------------
  |  Branch (628:12): [True: 0, False: 0]
  ------------------
  629|      0|          {
  630|      0|            TempStartNumber=StartNumber;
  631|       |            //Try to skip objects now
  632|      0|            int ret = pInFormat->SkipObjects(StartNumber-1,this);
  633|      0|            if(ret==-1) //error
  ------------------
  |  Branch (633:16): [True: 0, False: 0]
  ------------------
  634|      0|              return false;
  635|      0|            if(ret==1) //success:objects skipped
  ------------------
  |  Branch (635:16): [True: 0, False: 0]
  ------------------
  636|      0|              {
  637|      0|                Count = StartNumber-1;
  638|      0|                StartNumber=0;
  639|      0|              }
  640|      0|          }
  641|      0|      }
  642|       |
  643|      8|    p = IsOption("l",GENOPTIONS);
  644|      8|    if(p)
  ------------------
  |  Branch (644:8): [True: 0, False: 8]
  ------------------
  645|      0|      {
  646|      0|        EndNumber=atoi(p);
  647|      0|        if(TempStartNumber && EndNumber<TempStartNumber)
  ------------------
  |  Branch (647:12): [True: 0, False: 0]
  |  Branch (647:31): [True: 0, False: 0]
  ------------------
  648|      0|          EndNumber=TempStartNumber;
  649|      0|      }
  650|       |
  651|      8|    return true;
  652|      8|  }
_ZN9OpenBabel12OBConversion10FindFormatEPKc:
  756|     16|  {
  757|     16|    return OBFormat::FindType(ID);
  758|     16|  }
_ZNK9OpenBabel12OBConversion8GetTitleEv:
  767|      2|  {
  768|      2|    return(InFilename.c_str());
  769|      2|  }
_ZN9OpenBabel12OBConversion11StreamState9pushInputERS0_:
  936|      8|  {
  937|      8|    assert(ownedStreams.size() == 0); //should be empty
  938|       |
  939|      8|    pStream = conv.pInput;
  940|      8|    std::copy(conv.ownedInStreams.begin(), conv.ownedInStreams.end(), std::back_inserter(ownedStreams));
  941|       |
  942|      8|    conv.pInput = nullptr;
  943|      8|    conv.ownedInStreams.clear();
  944|      8|  }
_ZN9OpenBabel12OBConversion11StreamState10pushOutputERS0_:
  967|      8|  {
  968|      8|    assert(ownedStreams.size() == 0); //should be empty
  969|       |
  970|      8|    pStream = conv.pOutput;
  971|      8|    std::copy(conv.ownedOutStreams.begin(), conv.ownedOutStreams.end(), std::back_inserter(ownedStreams));
  972|       |
  973|      8|    conv.pOutput = nullptr;
  974|      8|    conv.ownedOutStreams.clear();
  975|      8|  }
_ZN9OpenBabel12OBConversion13SetFirstInputEb:
 1188|      8|  {
 1189|      8|    m_IsFirstInput = b;
 1190|       |/*    //Also set or clear a general option
 1191|       |    if(b)
 1192|       |      AddOption("firstinput",GENOPTIONS);
 1193|       |    else
 1194|       |      RemoveOption("firstinput",GENOPTIONS);
 1195|       |  */
 1196|      8|  }
_ZN9OpenBabel12OBConversion8IsOptionEPKcNS0_11Option_typeE:
 1627|     48|  {
 1628|       |    //Returns NULL if option not found or a pointer to the text if it is
 1629|     48|    map<string,string>::iterator pos;
 1630|     48|    pos = OptionsArray[opttyp].find(opt);
 1631|     48|    if(pos==OptionsArray[opttyp].end())
  ------------------
  |  Branch (1631:8): [True: 48, False: 0]
  ------------------
 1632|     48|      return nullptr;
 1633|      0|    return pos->second.c_str();
 1634|     48|  }
_ZN9OpenBabel12OBConversion16OptionParamArrayENS0_11Option_typeE:
 1667|    636|  {
 1668|    636|    static OPAMapType opa[3];
 1669|    636|    return opa[typ];
 1670|    636|  }
_ZN9OpenBabel12OBConversion19RegisterOptionParamENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8OBFormatEiNS0_11Option_typeE:
 1674|    212|  {
 1675|       |    //Gives error message if the number of parameters conflicts with an existing registration
 1676|    212|    map<string,int>::iterator pos;
 1677|    212|    pos =	OptionParamArray(typ).find(name);
 1678|    212|    if(pos!=OptionParamArray(typ).end())
  ------------------
  |  Branch (1678:8): [True: 78, False: 134]
  ------------------
 1679|     78|      {
 1680|     78|        if(pos->second!=numberParams)
  ------------------
  |  Branch (1680:12): [True: 0, False: 78]
  ------------------
 1681|      0|          {
 1682|      0|            string description("API");
 1683|      0|            if(pFormat)
  ------------------
  |  Branch (1683:16): [True: 0, False: 0]
  ------------------
 1684|      0|              description=pFormat->Description();
 1685|      0|            obErrorLog.ThrowError(__FUNCTION__,
 1686|      0|                                  "The number of parameters needed by option \"" + name + "\" in "
 1687|      0|                                  + description.substr(0,description.find('\n'))
 1688|      0|                                  + " differs from an earlier registration.", obError);
 1689|      0|            return;
 1690|      0|          }
 1691|     78|      }
 1692|    212|    OptionParamArray(typ)[name] = numberParams;
 1693|    212|  }

_ZN9OpenBabel7OBErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_S9_S9_NS_14obMessageLevelE:
   41|      5|    _method(method), _errorMsg(errorMsg), _explanation(explanation),
   42|      5|    _possibleCause(possibleCause), _suggestedRemedy(suggestedRemedy),
   43|      5|    _level(level)
   44|      5|  { }
_ZN9OpenBabel16OBMessageHandlerC2Ev:
  146|      2|    _outputLevel(obWarning), _outputStream(&clog), _logging(true), _maxEntries(100)
  147|      2|  {
  148|      2|    _messageCount[0] = _messageCount[1] = _messageCount[2] = 0;
  149|      2|    _messageCount[3] = _messageCount[4] = 0;
  150|      2|    _filterStreamBuf = _inWrapStreamBuf = nullptr;
  151|       |    //  StartErrorWrap(); // (don't turn on error wrapping by default)
  152|      2|  }
_ZN9OpenBabel16OBMessageHandler10ThrowErrorENS_7OBErrorENS_14errorQualifierE:
  163|      5|  {
  164|      5|    if (!_logging)
  ------------------
  |  Branch (164:9): [True: 5, False: 0]
  ------------------
  165|      5|      return;
  166|       |
  167|       |    //Output error message if level sufficiently high and, if onceOnly set, it has not been logged before
  168|      0|    if (err.GetLevel() <= _outputLevel &&
  ------------------
  |  Branch (168:9): [True: 0, False: 0]
  |  Branch (168:9): [True: 0, False: 0]
  ------------------
  169|      0|      (qualifier!=onceOnly || find(_messageList.begin(), _messageList.end(), err)==_messageList.end()))
  ------------------
  |  Branch (169:8): [True: 0, False: 0]
  |  Branch (169:31): [True: 0, False: 0]
  ------------------
  170|      0|    {
  171|      0|      *_outputStream << err;
  172|      0|    }
  173|       |
  174|      0|    _messageList.push_back(err);
  175|      0|    _messageCount[err.GetLevel()]++;
  176|      0|    if (_maxEntries != 0 && _messageList.size() > _maxEntries)
  ------------------
  |  Branch (176:9): [True: 0, False: 0]
  |  Branch (176:29): [True: 0, False: 0]
  ------------------
  177|      0|      _messageList.pop_front();
  178|      0|  }
_ZN9OpenBabel16OBMessageHandler10ThrowErrorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_14obMessageLevelENS_14errorQualifierE:
  183|      5|  {
  184|      5|    if (errorMsg.length() > 1)
  ------------------
  |  Branch (184:9): [True: 5, False: 0]
  ------------------
  185|      5|      {
  186|      5|        OBError err(method, errorMsg, "", "", "", level);
  187|      5|        ThrowError(err, qualifier);
  188|      5|      }
  189|      5|  }

_ZN9OpenBabel16OBMoleculeFormat18ReadChemObjectImplEPNS_12OBConversionEPNS_8OBFormatE:
   36|      8|  {
   37|      8|    std::istream *ifs = pConv->GetInStream();
   38|      8|    if (!ifs || !ifs->good())
  ------------------
  |  Branch (38:9): [True: 0, False: 8]
  |  Branch (38:17): [True: 0, False: 8]
  ------------------
   39|      0|      return false;
   40|       |
   41|      8|    OBMol* pmol = new OBMol;
   42|       |
   43|      8|    if(pConv->IsOption("C",OBConversion::GENOPTIONS))
  ------------------
  |  Branch (43:8): [True: 0, False: 8]
  ------------------
   44|      0|      return DeferMolOutput(pmol, pConv, pFormat);
   45|       |
   46|      8|    bool ret=true;
   47|      8|   if(pConv->IsOption("separate",OBConversion::GENOPTIONS))
  ------------------
  |  Branch (47:7): [True: 0, False: 8]
  ------------------
   48|      0|   {
   49|       |     //On first call, separate molecule and put fragments in MolArray.
   50|       |     //On subsequent calls, remove a fragment from MolArray and send it for writing
   51|       |     //Done this way so that each fragment can be written to its own file (with -m option)
   52|      0|     if(!StoredMolsReady)
  ------------------
  |  Branch (52:9): [True: 0, False: 0]
  ------------------
   53|      0|     {
   54|      0|       while(ret) //do all the molecules in the file
  ------------------
  |  Branch (54:14): [True: 0, False: 0]
  ------------------
   55|      0|       {
   56|      0|         ret = pFormat->ReadMolecule(pmol,pConv);
   57|       |
   58|      0|         if(ret && (pmol->NumAtoms() > 0 || (pFormat->Flags()&ZEROATOMSOK)))
  ------------------
  |  |   34|      0|#define ZEROATOMSOK     0x08
  ------------------
  |  Branch (58:13): [True: 0, False: 0]
  |  Branch (58:21): [True: 0, False: 0]
  |  Branch (58:45): [True: 0, False: 0]
  ------------------
   59|      0|         {
   60|      0|           vector<OBMol> SepArray = pmol->Separate(); //use un-transformed molecule
   61|       |           //Add an appropriate title to each fragment
   62|      0|           if(SepArray.size()>1)
  ------------------
  |  Branch (62:15): [True: 0, False: 0]
  ------------------
   63|      0|             for (unsigned int i=0; i<SepArray.size(); ++i)
  ------------------
  |  Branch (63:37): [True: 0, False: 0]
  ------------------
   64|      0|             {
   65|      0|               stringstream ss;
   66|      0|               ss << pmol->GetTitle() << '#' << i+1;
   67|      0|               string title = ss.str();
   68|      0|               SepArray[i].SetTitle(title);
   69|      0|             }
   70|      0|           else
   71|      0|              SepArray[0].SetTitle(pmol->GetTitle());
   72|       |
   73|      0|           copy(SepArray.begin(),SepArray.end(),back_inserter(MolArray));
   74|      0|         }
   75|      0|       }
   76|      0|       reverse(MolArray.begin(),MolArray.end());
   77|      0|       StoredMolsReady = true;
   78|       |       //Clear the flags of the input stream(which may have found eof) to ensure will
   79|       |       //try to read anothe molecule and allow the stored ones to be sent for output.
   80|      0|       pConv->GetInStream()->clear();
   81|      0|     }
   82|       |
   83|      0|     if(MolArray.empty()) //normal end of fragments
  ------------------
  |  Branch (83:9): [True: 0, False: 0]
  ------------------
   84|      0|       ret =false;
   85|      0|     else
   86|      0|     {
   87|       |       // Copying is needed because the OBMol passed to AddChemObject will be deleted.
   88|       |       // The OBMol in the vector is deleted here.
   89|      0|       OBMol* pMolCopy = new OBMol( MolArray.back());
   90|      0|       MolArray.pop_back();
   91|      0|       ret = pConv->AddChemObject(
   92|      0|           pMolCopy->DoTransformations(pConv->GetOptions(OBConversion::GENOPTIONS), pConv))!=0;
   93|      0|     }
   94|      0|     if(!ret)
  ------------------
  |  Branch (94:9): [True: 0, False: 0]
  ------------------
   95|      0|       StoredMolsReady = false;
   96|       |
   97|      0|     delete pmol;
   98|      0|     return ret;
   99|      0|   }
  100|       |
  101|      8|    ret=pFormat->ReadMolecule(pmol,pConv);
  102|       |
  103|      8|    OBMol* ptmol = nullptr;
  104|       |    //Molecule is valid if it has some atoms
  105|       |    //or it represents a reaction
  106|       |    //or the format allows zero-atom molecules and it has a title or properties
  107|      8|    if(ret && (pmol->NumAtoms() > 0
  ------------------
  |  Branch (107:8): [True: 0, False: 8]
  |  Branch (107:16): [True: 0, False: 0]
  ------------------
  108|      0|      || pmol->IsReaction()
  ------------------
  |  Branch (108:10): [True: 0, False: 0]
  ------------------
  109|      0|      || (pFormat->Flags()&ZEROATOMSOK && (*pmol->GetTitle() || pmol->HasData(1)))))
  ------------------
  |  |   34|      0|#define ZEROATOMSOK     0x08
  ------------------
  |  Branch (109:11): [True: 0, False: 0]
  |  Branch (109:44): [True: 0, False: 0]
  |  Branch (109:65): [True: 0, False: 0]
  ------------------
  110|      0|    {
  111|      0|      ptmol = static_cast<OBMol*>(pmol->DoTransformations(pConv->GetOptions(OBConversion::GENOPTIONS),pConv));
  112|      0|      if(ptmol && (pConv->IsOption("j",OBConversion::GENOPTIONS)
  ------------------
  |  Branch (112:10): [True: 0, False: 0]
  |  Branch (112:20): [True: 0, False: 0]
  ------------------
  113|      0|                || pConv->IsOption("join",OBConversion::GENOPTIONS)))
  ------------------
  |  Branch (113:20): [True: 0, False: 0]
  ------------------
  114|      0|      {
  115|       |        //With j option, accumulate all mols in one stored in this class
  116|      0|        if(pConv->IsFirstInput())
  ------------------
  |  Branch (116:12): [True: 0, False: 0]
  ------------------
  117|      0|          _jmol = new OBMol;
  118|      0|        pConv->AddChemObject(_jmol);
  119|       |        //will be discarded in WriteChemObjectImpl until the last input mol. This complication
  120|       |        //is needed to allow joined molecules to be from different files. pOb1 in AddChem Object
  121|       |        //is zeroed at the end of a file and _jmol is in danger of not being output.
  122|      0|        *_jmol += *ptmol;
  123|      0|        delete ptmol;
  124|      0|        return true;
  125|      0|      }
  126|      0|    }
  127|      8|    else
  128|      8|      delete pmol;
  129|       |
  130|       |    // Normal operation - send molecule to be written
  131|      8|    ret = ret && (pConv->AddChemObject(ptmol)!=0); //success of both writing and reading
  ------------------
  |  Branch (131:11): [True: 0, False: 8]
  |  Branch (131:18): [True: 0, False: 0]
  ------------------
  132|      8|    return ret;
  133|      8|  }

_ZN9OpenBabel12OpAddInIndexC2EPKc:
   30|      2|  OpAddInIndex(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel14OpAddNonPolarHC2EPKc:
   29|      2|  OpAddNonPolarH(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel11OpAddPolarHC2EPKc:
   29|      2|  OpAddPolarH(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel11OpCanonicalC2EPKc:
   31|      2|  OpCanonical(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel14OpDelNonPolarHC2EPKc:
   29|      2|  OpDelNonPolarH(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel11OpDelPolarHC2EPKc:
   29|      2|  OpDelPolarH(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel8OpFillUCC2EPKc:
   38|      2|  OpFillUC(const char* ID) : OBOp(ID, false){
   39|      2|    OBConversion::RegisterOptionParam("fillUC", nullptr, 1, OBConversion::GENOPTIONS);
   40|      2|  }

_ZN9OpenBabel8OpEnergyC2EPKc:
   49|      2|      OpEnergy(const char *ID) : OBOp(ID, false) {}
_ZN9OpenBabel10OpMinimizeC2EPKc:
  138|      2|      OpMinimize(const char* ID) : OBOp(ID, false) {}

_ZN9OpenBabel7OpGen2DC2EPKc:
   33|      2|  OpGen2D(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel7OpGen3DC2EPKc:
   36|      2|  OpGen3D(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel6OpNewSC2EPKc:
   48|      4|  OpNewS(const char* ID) : OBOp(ID, false){}

_ZN9OpenBabel15OpPartialChargeC2EPKc:
   34|      2|  OpPartialCharge(const char* ID) : OBOp(ID, false) {
   35|      2|    OBConversion::RegisterOptionParam(ID, nullptr, 1, OBConversion::GENOPTIONS);
   36|      2|  }

_ZN9OpenBabel16OpReadConformersC2EPKc:
   31|      2|  OpReadConformers(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel6OpSortC2EPKc:
   48|      2|  OpSort(const char* ID) : OBOp(ID, false)
   49|      2|  {
   50|      2|    OBConversion::RegisterOptionParam(ID, nullptr, 1, OBConversion::GENOPTIONS);
   51|      2|  }

_ZN9OpenBabel10OpExtraOutC2EPKc:
  122|      2|  OpExtraOut(const char* ID) : OBOp(ID, false){};

_ZN9OpenBabel8OBPlugin10GetTypeMapEPKc:
   30|      1|{
   31|      1|  PluginMapType::iterator itr;
   32|       |
   33|       |  // Make sure the plugins are loaded
   34|      1|  if (AllPluginsLoaded == 0) {
  ------------------
  |  Branch (34:7): [True: 0, False: 1]
  ------------------
   35|      0|    OBPlugin::LoadAllPlugins();
   36|      0|  }
   37|       |
   38|      1|  itr = PluginMap().find(PluginID);
   39|      1|  if(itr!=PluginMap().end())
  ------------------
  |  Branch (39:6): [True: 0, False: 1]
  ------------------
   40|      0|    return itr->second->GetMap();
   41|      1|  return PluginMap();//error: type not found; return plugins map
   42|      1|}
_ZN9OpenBabel8OBPlugin14LoadAllPluginsEv:
   47|      1|{
   48|      1|  int count = 0;
   49|       |#if  defined(USING_DYNAMIC_LIBS)
   50|       |  // Depending on availability, look successively in
   51|       |  // FORMATFILE_DIR, executable directory or current directory
   52|       |  string TargetDir;
   53|       |
   54|       |#ifdef FORMATFILE_DIR
   55|       |  TargetDir="FORMATFILE_DIR";
   56|       |#endif
   57|       |
   58|       |  DLHandler::getConvDirectory(TargetDir);
   59|       |
   60|       |  vector<string> files;
   61|       |  if(!DLHandler::findFiles(files,DLHandler::getFormatFilePattern(),TargetDir)) {
   62|       |    obErrorLog.ThrowError(__FUNCTION__, "Unable to find OpenBabel plugins. Try setting the BABEL_LIBDIR environment variable.", obError);
   63|       |    return;
   64|       |  }
   65|       |
   66|       |  vector<string>::iterator itr;
   67|       |  for(itr=files.begin();itr!=files.end();++itr) {
   68|       |    if(DLHandler::openLib(*itr))
   69|       |      count++;
   70|       |  }
   71|       |  if(!count) {
   72|       |    string error = "No valid OpenBabel plugs found in "+TargetDir;
   73|       |    obErrorLog.ThrowError(__FUNCTION__, error, obError);
   74|       |    return;
   75|       |  }
   76|       |#else
   77|      1|  count = 1; // Avoid calling this function several times
   78|      1|#endif //USING_DYNAMIC_LIBS
   79|       |
   80|       |  // Status have to be updated now
   81|      1|  AllPluginsLoaded = count;
   82|       |
   83|       |  // Make instances for plugin classes defined in the data file.
   84|       |  // This is hook for OBDefine, but does nothing if it is not loaded
   85|       |  // or if plugindefines.txt is not found.
   86|      1|  OBPlugin* pdef = OBPlugin::GetPlugin("loaders","define");
   87|      1|  if(pdef) {
  ------------------
  |  Branch (87:6): [True: 0, False: 1]
  ------------------
   88|      0|    static vector<string> vec(3);
   89|      0|    vec[1] = string("define");
   90|      0|    vec[2] = string("plugindefines.txt");
   91|      0|    pdef->MakeInstance(vec);
   92|      0|  }
   93|       |
   94|      1|  return;
   95|      1|}
_ZN9OpenBabel8OBPlugin12BaseFindTypeERNSt3__13mapIPKcPS0_NS_11CharPtrLessENS1_9allocatorINS1_4pairIKS4_S5_EEEEEES4_:
   98|     17|{
   99|       |  // Make sure the plugins are loaded
  100|     17|  if (AllPluginsLoaded == 0) {
  ------------------
  |  Branch (100:7): [True: 0, False: 17]
  ------------------
  101|      0|    OBPlugin::LoadAllPlugins();
  102|      0|  }
  103|       |
  104|     17|  if(!ID || !*ID)
  ------------------
  |  Branch (104:6): [True: 0, False: 17]
  |  Branch (104:13): [True: 0, False: 17]
  ------------------
  105|      0|    return nullptr;
  106|     17|  PluginMapType::iterator itr = Map.find(ID);
  107|     17|  if(itr==Map.end())
  ------------------
  |  Branch (107:6): [True: 1, False: 16]
  ------------------
  108|      1|    return nullptr;
  109|     16|  else
  110|     16|    return itr->second;
  111|     17|}
_ZN9OpenBabel8OBPlugin9GetPluginEPKcS2_:
  114|      1|{
  115|      1|  if (Type != nullptr)
  ------------------
  |  Branch (115:7): [True: 1, False: 0]
  ------------------
  116|      1|    return BaseFindType(GetTypeMap(Type), ID);
  117|       |
  118|       |  // Make sure the plugins are loaded
  119|      0|  if (AllPluginsLoaded == 0) {
  ------------------
  |  Branch (119:7): [True: 0, False: 0]
  ------------------
  120|      0|    OBPlugin::LoadAllPlugins();
  121|      0|  }
  122|       |
  123|       |  //When Type==NULL, search all types for matching ID and stop when found
  124|      0|  PluginMapType::iterator itr;
  125|      0|  for(itr=PluginMap().begin();itr!= PluginMap().end();++itr)
  ------------------
  |  Branch (125:31): [True: 0, False: 0]
  ------------------
  126|      0|  {
  127|      0|    OBPlugin* result = BaseFindType(itr->second->GetMap(), ID);
  128|      0|    if(result)
  ------------------
  |  Branch (128:8): [True: 0, False: 0]
  ------------------
  129|      0|      return result;
  130|      0|  }
  131|      0|  return nullptr; //not found
  132|      0|}
_ZN9OpenBabel8OBPlugin12ListAsVectorEPKcS2_RNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE:
  135|      1|{
  136|      1|  PluginMapType::iterator itr;
  137|      1|  bool ret=true;
  138|       |
  139|       |  // Make sure the plugins are loaded
  140|      1|  if (AllPluginsLoaded == 0) {
  ------------------
  |  Branch (140:7): [True: 1, False: 0]
  ------------------
  141|      1|    LoadAllPlugins();
  142|      1|  }
  143|       |
  144|      1|  if(PluginID)
  ------------------
  |  Branch (144:6): [True: 1, False: 0]
  ------------------
  145|      1|  {
  146|      1|    if(*PluginID!=0 && strcmp(PluginID, "plugins"))
  ------------------
  |  Branch (146:8): [True: 1, False: 0]
  |  Branch (146:24): [True: 1, False: 0]
  ------------------
  147|      1|    {
  148|       |      //List the sub classes of the specified type
  149|      1|      itr = PluginMap().find(PluginID);
  150|      1|      if(itr!=PluginMap().end())
  ------------------
  |  Branch (150:10): [True: 1, False: 0]
  ------------------
  151|      1|      {
  152|      1|        bool onlyIDs = param != nullptr && strstr(param, "ids") != nullptr;
  ------------------
  |  Branch (152:24): [True: 1, False: 0]
  |  Branch (152:44): [True: 1, False: 0]
  ------------------
  153|       |        //Get map of plugin type (like OBFingerprint) and output its contents
  154|      1|        PluginMapType Map = itr->second->GetMap();
  155|    161|        for(itr=Map.begin(); itr!=Map.end(); ++itr)
  ------------------
  |  Branch (155:30): [True: 160, False: 1]
  ------------------
  156|    160|        {
  157|    160|          if(*(itr->first)=='_')//no listing when ID starts with '_'
  ------------------
  |  Branch (157:14): [True: 0, False: 160]
  ------------------
  158|      0|            continue;
  159|    160|          if(onlyIDs)
  ------------------
  |  Branch (159:14): [True: 160, False: 0]
  ------------------
  160|    160|            vlist.push_back(itr->first);
  161|      0|          else
  162|      0|          {
  163|      0|            string txt;
  164|      0|            if((itr->second)->Display(txt, param, itr->first))
  ------------------
  |  Branch (164:16): [True: 0, False: 0]
  ------------------
  165|      0|              vlist.push_back(txt);
  166|      0|          }
  167|    160|        }
  168|      1|        return true;
  169|      1|      }
  170|      0|      ret=false; //asked for a type not available; provide plugin types instead
  171|      0|    }
  172|      1|  }
  173|       |  //List the plugin types
  174|      0|  for(itr=PluginMap().begin();itr!= PluginMap().end();++itr)
  ------------------
  |  Branch (174:31): [True: 0, False: 0]
  ------------------
  175|      0|    vlist.push_back(itr->first);
  176|      0|  return ret;
  177|      1|}

_ZN9OpenBabel8tokenizeERNSt3__16vectorINS0_12basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEENS5_IS7_EEEEPKcSC_:
   38|      3|  {
   39|      3|    vcr.clear();
   40|      3|    if (!buf || !delimstr)
  ------------------
  |  Branch (40:9): [True: 0, False: 3]
  |  Branch (40:17): [True: 0, False: 3]
  ------------------
   41|      0|      return false;
   42|       |
   43|      3|    string s(buf);
   44|      3|    s += delimstr[0]; //forces last token to be parsed
   45|      3|    size_t startpos=0,endpos=0;
   46|       |
   47|      3|    for (;;)
   48|      3|      {
   49|      3|        startpos = s.find_first_not_of(delimstr,startpos);
   50|      3|        endpos = s.find_first_of(delimstr,startpos);
   51|       |
   52|      3|        if (endpos <= s.size() && startpos <= s.size())
  ------------------
  |  Branch (52:13): [True: 0, False: 3]
  |  Branch (52:35): [True: 0, False: 0]
  ------------------
   53|      0|          vcr.push_back(s.substr(startpos,endpos-startpos));
   54|      3|        else
   55|      3|          break;
   56|       |
   57|      0|        startpos = endpos+1;
   58|      0|      }
   59|       |
   60|      3|    return(true);
   61|      3|  }
_ZN9OpenBabel4TrimERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  136|     10|  {
  137|     10|    string::size_type pos = txt.find_last_not_of(" \t\n\r");
  138|     10|    if(pos!=string::npos)
  ------------------
  |  Branch (138:8): [True: 4, False: 6]
  ------------------
  139|      4|      txt.erase(pos+1);
  140|      6|    else
  141|      6|      txt.erase();
  142|       |
  143|     10|    pos = txt.find_first_not_of(" \t\n\r");
  144|     10|    if(pos!=string::npos)
  ------------------
  |  Branch (144:8): [True: 4, False: 6]
  ------------------
  145|      4|      txt.erase(0, pos);
  146|      6|    else
  147|      6|      txt.erase();
  148|     10|    return txt;
  149|     10|  }

_ZN9OpenBabel11OBRingTyperC2Ev:
  245|      2|  {
  246|      2|    _init = false;
  247|      2|    _dir = BABEL_DATADIR;
  ------------------
  |  |    4|      2|#define BABEL_DATADIR "/usr/local/share/openbabel"
  ------------------
  248|      2|    _envvar = "BABEL_DATADIR";
  249|      2|    _filename = "ringtyp.txt";
  250|      2|    _subdir = "data";
  251|      2|    _dataptr = RingTypeData;
  252|      2|  }

_ZN18FuzzedDataProviderC2EPKhm:
   37|      8|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv:
  181|      8|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() {
  182|      8|  return ConsumeRandomLengthString(remaining_bytes_);
  183|      8|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|      8|FuzzedDataProvider::ConsumeRandomLengthString(size_t max_length) {
  154|       |  // Reads bytes from the start of |data_ptr_|. Maps "\\" to "\", and maps "\"
  155|       |  // followed by anything else to the end of the string. As a result of this
  156|       |  // logic, a fuzzer can insert characters into the string, and the string
  157|       |  // will be lengthened to include those new characters, resulting in a more
  158|       |  // stable fuzzer than picking the length of a string independently from
  159|       |  // picking its contents.
  160|      8|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|      8|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  5.24M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 5.24M, False: 5]
  |  Branch (164:40): [True: 5.24M, False: 0]
  ------------------
  165|  5.24M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  5.24M|    Advance(1);
  167|  5.24M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 3, False: 5.24M]
  |  Branch (167:25): [True: 3, False: 0]
  ------------------
  168|      3|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|      3|      Advance(1);
  170|      3|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 3, False: 0]
  ------------------
  171|      3|        break;
  172|      3|    }
  173|  5.24M|    result += next;
  174|  5.24M|  }
  175|       |
  176|      8|  result.shrink_to_fit();
  177|      8|  return result;
  178|      8|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  378|  5.24M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  379|  5.24M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  380|  5.24M|  static_assert(!std::numeric_limits<TU>::is_signed,
  381|  5.24M|                "Source type must be unsigned.");
  382|       |
  383|       |  if constexpr (std::numeric_limits<TS>::is_modulo)
  384|       |    return static_cast<TS>(value);
  385|       |
  386|       |  // Avoid using implementation-defined unsigned to signed conversions.
  387|       |  // To learn more, see https://stackoverflow.com/questions/13150449.
  388|  5.24M|  constexpr auto TS_max = static_cast<TU>(std::numeric_limits<TS>::max());
  389|  5.24M|  if (value <= TS_max) {
  ------------------
  |  Branch (389:7): [True: 4.10M, False: 1.13M]
  ------------------
  390|  4.10M|    return static_cast<TS>(value);
  391|  4.10M|  } else {
  392|  1.13M|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  393|  1.13M|    return TS_min + static_cast<TS>(value - TS_min);
  394|  1.13M|  }
  395|  5.24M|}
_ZN18FuzzedDataProvider7AdvanceEm:
  343|  5.24M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  344|  5.24M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (344:7): [True: 0, False: 5.24M]
  ------------------
  345|      0|    abort();
  346|       |
  347|  5.24M|  data_ptr_ += num_bytes;
  348|  5.24M|  remaining_bytes_ -= num_bytes;
  349|  5.24M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|     16|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|     16|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|     16|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|     16|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 16]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|     16|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|     16|  uint64_t result = 0;
  215|     16|  size_t offset = 0;
  216|       |
  217|     32|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 32, False: 0]
  |  Branch (217:43): [True: 16, False: 16]
  ------------------
  218|     16|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 16, False: 0]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|     16|    --remaining_bytes_;
  226|     16|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|     16|    offset += CHAR_BIT;
  228|     16|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|     16|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 16, False: 0]
  ------------------
  232|     16|    result = result % (range + 1);
  233|       |
  234|     16|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|     16|}

_Z13getAllFormatsv:
   13|      1|std::vector<std::string> getAllFormats() {
   14|      1|    std::vector<std::string> formats;
   15|      1|    OpenBabel::OBPlugin::ListAsVector("formats", "ids", formats);
   16|      1|    std::sort(formats.begin(), formats.end());
   17|      1|    return formats;
   18|      1|}
_Z12randomFormatR18FuzzedDataProvider:
   20|     16|const char *randomFormat(FuzzedDataProvider &fdp) {
   21|     16|    static std::vector<std::string> formats = getAllFormats();
   22|     16|    return formats[fdp.ConsumeIntegralInRange<int>(0, formats.size() - 1)].c_str();
   23|     16|}
LLVMFuzzerTestOneInput:
   25|      8|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   26|      8|    using namespace OpenBabel;
   27|      8|    obErrorLog.StopLogging();
   28|       |
   29|      8|    FuzzedDataProvider fdp(Data, Size);
   30|      8|    OBConversion conv;
   31|      8|    conv.SetInFormat(randomFormat(fdp));
   32|      8|    conv.SetOutFormat(randomFormat(fdp));
   33|       |
   34|      8|    std::ostringstream outStream;
   35|      8|    std::istringstream inStream(fdp.ConsumeRandomLengthString());
   36|       |
   37|      8|    try {
   38|      8|        conv.Convert(&inStream, &outStream);
   39|      8|    } catch (...) {
   40|       |        // no error handling
   41|      0|    }
   42|       |
   43|      8|    return 0;
   44|      8|}