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

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

_ZNK9OpenBabel5OBMol8NumAtomsEv:
  276|      3|    unsigned int NumAtoms() const         {  return(_natoms); }
_ZN9OpenBabel5OBMol18SetChainsPerceivedEb:
  398|      1|    void   SetChainsPerceived(bool value = true)      { SET_OR_UNSET_FLAG(OB_CHAINS_MOL);      }
  ------------------
  |  |  113|      1|  if (value) SetFlag(X); \
  |  |  ------------------
  |  |  |  Branch (113:7): [True: 1, False: 0]
  |  |  ------------------
  |  |  114|      1|  else     UnsetFlag(X);
  ------------------
_ZN9OpenBabel5OBMol7HasFlagEi:
  418|      2|    bool   HasFlag(int flag)   { return (_flags & flag) ? true : false; }
  ------------------
  |  Branch (418:41): [True: 0, False: 2]
  ------------------
_ZN9OpenBabel5OBMol7SetFlagEi:
  419|      1|    void   SetFlag(int flag)   { _flags |= flag; }
_ZN9OpenBabel5OBMol10IsReactionEv:
  612|      2|    bool IsReaction()                  { return HasFlag(OB_REACTION_MOL); }
  ------------------
  |  |  107|      2|#define OB_REACTION_MOL          (1<<22)
  ------------------
_ZN9OpenBabel5OBMol5EmptyEv:
  617|      7|    bool Empty()                       { return(_natoms == 0);          }
_ZN9OpenBabel5OBMol12BeginResidueERNSt3__111__wrap_iterIPPNS_9OBResidueEEE:
  703|     11|    {
  704|     11|      i = _residue.begin();
  705|     11|      return((i == _residue.end()) ? nullptr:*i);
  ------------------
  |  Branch (705:14): [True: 11, False: 0]
  ------------------
  706|     11|    }

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

_ZN9OpenBabel16OBMessageHandler11StopLoggingEv:
  128|     11|      void StopLogging()  { _logging = false; }
_ZN9OpenBabel16OBMessageHandler14GetOutputLevelEv:
  142|      7|      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|     11|  { 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.20k|  { return strcasecmp(p1,p2)<0; }
_ZN9OpenBabel8OBPlugin9PluginMapEv:
  134|    435|  {
  135|    435|    static PluginMapType m;
  136|    435|    return m;
  137|    435|  }
_ZN9OpenBabel8OBFormat3MapEv:
  197|    668|  static PluginMapType& Map() {\
  198|    668|    static PluginMapType m;\
  199|    668|    return m;\
  200|    668|  }\
_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|     23|  static BaseClass* FindType(const char* ID) {\
  222|     23|    if (!ID || *ID==0 || *ID==' ') {\
  ------------------
  |  Branch (222:9): [True: 0, False: 23]
  |  Branch (222:16): [True: 0, False: 23]
  |  Branch (222:26): [True: 0, False: 23]
  ------------------
  223|      0|      return Default();\
  224|      0|    }\
  225|     23|    return static_cast<BaseClass*>(BaseFindType(Map(),ID));\
  226|     23|  }
_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|      7|  {
   80|      7|    if (!_vdata.empty()) //clean up generic data
  ------------------
  |  Branch (80:9): [True: 0, False: 7]
  ------------------
   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|      7|    return(true);
   89|      7|  }

_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|      6|    {
   96|      6|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      6|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      6|#define WRITEONEONLY    0x20
  ------------------
   97|      6|    }

_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|    }
_ZN9OpenBabel14ADFInputFormat5FlagsEv:
  288|      2|    {
  289|      2|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      2|#define WRITEONEONLY    0x20
  ------------------
  290|      2|    }
_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|      7|    {
   54|      7|      return NOTREADABLE;
  ------------------
  |  |   31|      7|#define NOTREADABLE     0x01
  ------------------
   55|      7|    }

_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|      2|    {
   53|      2|      return READONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
   54|      2|    }
_ZN9OpenBabel13CHEM3D2Format5FlagsEv:
  125|      3|    {
  126|      3|      return READONEONLY;
  ------------------
  |  |   32|      3|#define READONEONLY     0x02
  ------------------
  127|      3|    }

_ZN9OpenBabel21ChemDrawBinaryXFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
  212|      1|{
  213|      1|  _molmap.clear();
  214|      1|  _graphicmap.clear();
  215|      1|  _groupmap.clear();
  216|      1|  OBMol* pmol=nullptr;
  217|      1|  bool ok = true;
  218|       |
  219|      1|  CDXReader cdxr(*pConv->GetInStream());
  220|      1|  readReactions = pConv->IsOption("m", OBConversion::INOPTIONS) == nullptr;
  221|       |
  222|       |  // Write CDX tree only if requested
  223|      1|  if(pConv->IsOption("d",OBConversion::INOPTIONS))
  ------------------
  |  Branch (223:6): [True: 0, False: 1]
  ------------------
  224|      0|  {
  225|      0|    unsigned wtoptions=0;
  226|      0|    if(pConv->IsOption("o",OBConversion::INOPTIONS))
  ------------------
  |  Branch (226:8): [True: 0, False: 0]
  ------------------
  227|      0|      wtoptions |= 1; //display objects only
  228|      0|    OBText* pText  = cdxr.WriteTree("chemdrawcdx.h", wtoptions);
  229|      0|    if(pText)
  ------------------
  |  Branch (229:8): [True: 0, False: 0]
  ------------------
  230|      0|    {
  231|      0|      pConv->AddChemObject(pText);
  232|      0|      return true;
  233|      0|    }
  234|      0|    return false;
  235|      0|  }
  236|       |
  237|       |  // Normal reading of molecules and reactions
  238|       |  //Top level parse 
  239|      2|  while(cdxr)
  ------------------
  |  Branch (239:9): [True: 1, False: 1]
  ------------------
  240|      1|  {
  241|      1|    if(!TopLevelParse(cdxr, pConv, 0))
  ------------------
  |  Branch (241:8): [True: 0, False: 1]
  ------------------
  242|      0|      return false;
  243|      1|  }
  244|       |
  245|       |  //At the end, output molecules that have not been used in a reaction
  246|      1|  map<CDXObjectID, OBMol*>::iterator mapiter = _molmap.begin();
  247|      1|  for(; mapiter!=_molmap.end(); ++mapiter)
  ------------------
  |  Branch (247:9): [True: 0, False: 1]
  ------------------
  248|      0|  {
  249|      0|    pmol = mapiter->second;
  250|      0|    if(!(pmol->GetFlags() & usedFlag) && strcmp(pmol->GetTitle(),"justplus"))
  ------------------
  |  Branch (250:8): [True: 0, False: 0]
  |  Branch (250:42): [True: 0, False: 0]
  ------------------
  251|      0|    {
  252|      0|      OBMol* ptmol = static_cast<OBMol*>(pmol->DoTransformations(
  253|      0|                    pConv->GetOptions(OBConversion::GENOPTIONS),pConv));
  254|      0|      if(!ptmol)
  ------------------
  |  Branch (254:10): [True: 0, False: 0]
  ------------------
  255|      0|        delete pmol;
  256|      0|      else
  257|      0|        if(!pConv->AddChemObject(ptmol))
  ------------------
  |  Branch (257:12): [True: 0, False: 0]
  ------------------
  258|      0|          return false; //error during writing
  259|      0|    }
  260|      0|  }
  261|       |
  262|      1|  return ok;
  263|      1|}
_ZN9OpenBabel21ChemDrawBinaryXFormat13TopLevelParseERNS_9CDXReaderEPNS_12OBConversionEi:
  267|      1|{
  268|      1|  bool ok = true;
  269|      1|  CDXTag tag;
  270|      1|  while((tag = cdxr.ReadNext(objectsOnly)))
  ------------------
  |  Branch (270:9): [True: 0, False: 1]
  ------------------
  271|      0|  {
  272|      0|    if(tag == kCDXObj_Group)
  ------------------
  |  Branch (272:8): [True: 0, False: 0]
  ------------------
  273|      0|    {
  274|      0|      CDXObjectID cid = cdxr.CurrentID();
  275|      0|      vector<CDXObjectID> v;
  276|      0|      _groupmap.insert(make_pair(cid,v)); //empty vector as yet
  277|      0|      TopLevelParse(cdxr, pConv, cid );
  278|      0|    }
  279|       |
  280|      0|    else if(tag==kCDXObj_Fragment)
  ------------------
  |  Branch (280:13): [True: 0, False: 0]
  ------------------
  281|      0|    {
  282|      0|      OBMol* pmol = new OBMol;
  283|       |      //Save all molecules to the end
  284|      0|      _molmap[cdxr.CurrentID()] = pmol;
  285|       |
  286|      0|      if(ContainingGroup)
  ------------------
  |  Branch (286:10): [True: 0, False: 0]
  ------------------
  287|      0|      {
  288|       |        // Add the id of this mol to the group's entry in _groupmap 
  289|      0|        GroupMapIterator gmapiter = _groupmap.find(ContainingGroup);
  290|      0|        if(gmapiter!=_groupmap.end())
  ------------------
  |  Branch (290:12): [True: 0, False: 0]
  ------------------
  291|      0|          gmapiter->second.push_back(cdxr.CurrentID());
  292|      0|      }
  293|      0|      ok = DoFragment(cdxr, pmol);
  294|      0|    }
  295|       |
  296|      0|    else if(tag == kCDXObj_ReactionStep && readReactions)
  ------------------
  |  Branch (296:13): [True: 0, False: 0]
  |  Branch (296:44): [True: 0, False: 0]
  ------------------
  297|      0|    {
  298|      0|      OBMol* pReact = new OBMol;
  299|      0|      pReact->SetIsReaction();
  300|      0|      ok = DoReaction(cdxr, pReact);
  301|       |      // Output OBReaction and continue 
  302|      0|      if(pReact)
  ------------------
  |  Branch (302:10): [True: 0, False: 0]
  ------------------
  303|      0|        if(!pConv->AddChemObject(pReact))
  ------------------
  |  Branch (303:12): [True: 0, False: 0]
  ------------------
  304|      0|          return false; //error during writing
  305|      0|    }
  306|       |
  307|      0|    else if(ok && tag==kCDXObj_Graphic)
  ------------------
  |  Branch (307:13): [True: 0, False: 0]
  |  Branch (307:19): [True: 0, False: 0]
  ------------------
  308|      0|    {
  309|      0|      while( (tag = cdxr.ReadNext()) )
  ------------------
  |  Branch (309:14): [True: 0, False: 0]
  ------------------
  310|      0|      {
  311|      0|        stringstream& ss = cdxr.data();
  312|      0|        if(tag == kCDXProp_Arrow_Type)
  ------------------
  |  Branch (312:12): [True: 0, False: 0]
  ------------------
  313|      0|        {
  314|      0|          char type1=0;
  315|      0|          UINT16 type2=0;
  316|      0|          if(cdxr.GetLen()==1)
  ------------------
  |  Branch (316:14): [True: 0, False: 0]
  ------------------
  317|      0|            ss.get(type1);
  318|      0|          else
  319|      0|            READ_INT16(ss,type2);
  ------------------
  |  |   80|      0|#    define READ_INT16(stream,data) \
  |  |   81|      0|(stream).read ((char*)&data, sizeof(data));
  ------------------
  320|      0|          if(type1==kCDXArrowType_Equilibrium || type2==kCDXArrowType_Equilibrium)
  ------------------
  |  Branch (320:14): [True: 0, False: 0]
  |  Branch (320:50): [True: 0, False: 0]
  ------------------
  321|      0|            _graphicmap[type1+type2] = equilArrow; //save in graphicmap
  322|      0|        }
  323|      0|      }
  324|      0|    }
  325|      0|  }
  326|      1|  return true;
  327|      1|}
_ZN9OpenBabel9CDXReader8ReadNextEbi:
  679|      1|{
  680|       |  //ostringstream treestream;
  681|      1|  CDXTag tag;
  682|      1|  CDXObjectID id;
  683|       |
  684|      1|  while(ifs) 
  ------------------
  |  Branch (684:9): [True: 1, False: 0]
  ------------------
  685|      1|  {
  686|      1|    READ_INT16(ifs, tag);
  ------------------
  |  |   80|      1|#    define READ_INT16(stream,data) \
  |  |   81|      1|(stream).read ((char*)&data, sizeof(data));
  ------------------
  687|      1|    if(tag==0)
  ------------------
  |  Branch (687:8): [True: 1, False: 0]
  ------------------
  688|      1|    {
  689|      1|      if(depth==0)
  ------------------
  |  Branch (689:10): [True: 1, False: 0]
  ------------------
  690|      1|      {
  691|      1|        ifs.setstate(ios::eofbit); //ignore everything after end of document
  692|      1|        return 0; //end of document
  693|      1|      }
  694|      0|      --depth;
  695|      0|      _tempback = ids.back(); //needed for WriteTree
  696|      0|      ids.pop_back();
  697|      0|      if(targetDepth<0 || depth == targetDepth)
  ------------------
  |  Branch (697:10): [True: 0, False: 0]
  |  Branch (697:27): [True: 0, False: 0]
  ------------------
  698|      0|        return 0; //end of object
  699|      0|    }
  700|      0|    else if(tag & kCDXTag_Object)
  ------------------
  |  Branch (700:13): [True: 0, False: 0]
  ------------------
  701|      0|    {
  702|      0|      READ_INT32(ifs, id);
  ------------------
  |  |   82|      0|#    define READ_INT32(stream,data) \
  |  |   83|      0|(stream).read ((char*)&data, sizeof(data));
  ------------------
  703|      0|      ids.push_back(id);
  704|      0|      ++depth;
  705|      0|      if(targetDepth<0 || depth-1 == targetDepth)
  ------------------
  |  Branch (705:10): [True: 0, False: 0]
  |  Branch (705:27): [True: 0, False: 0]
  ------------------
  706|      0|        return tag; //object
  707|      0|    }
  708|      0|    else
  709|      0|    {
  710|       |      //property
  711|      0|      READ_INT16(ifs, _len);
  ------------------
  |  |   80|      0|#    define READ_INT16(stream,data) \
  |  |   81|      0|(stream).read ((char*)&data, sizeof(data));
  ------------------
  712|       |
  713|      0|      if(objectsOnly)
  ------------------
  |  Branch (713:10): [True: 0, False: 0]
  ------------------
  714|      0|        ifs.ignore(_len);
  715|      0|      else
  716|      0|      {
  717|       |        //copy property data to buffer
  718|      0|        char* p = new char[_len+1];
  719|      0|        ifs.read(p, _len);
  720|      0|        _buf.assign(p, _len);
  721|      0|        delete[] p;
  722|      0|        return tag; //property
  723|      0|      }
  724|      0|    }
  725|      1|  }
  726|      0|  return 0;
  727|      1|}
_ZN9OpenBabel9CDXReaderC2ERNSt3__113basic_istreamIcNS1_11char_traitsIcEEEE:
  738|      1|CDXReader::CDXReader(std::istream& is) : ifs(is), depth(0)
  739|      1|{
  740|       |  //ReadHeader
  741|      1|  char buffer[kCDX_HeaderStringLen+1];
  742|      1|  ifs.read(buffer,kCDX_HeaderStringLen);
  743|      1|  buffer[kCDX_HeaderStringLen] = '\0';
  744|      1|  if(strncmp(buffer, kCDX_HeaderString, kCDX_HeaderStringLen) == 0)
  ------------------
  |  |   52|      1|#define kCDX_HeaderString "VjCD0100"
  ------------------
  |  Branch (744:6): [True: 0, False: 1]
  ------------------
  745|      0|    ifs.ignore(kCDX_HeaderLength - kCDX_HeaderStringLen);	// Discard rest of header.
  ------------------
  |  |   54|      0|#define kCDX_HeaderLength 28
  ------------------
  746|      1|  else
  747|      1|  {
  748|       |    // No active exception here: a bare `throw;` would call std::terminate.
  749|       |    // Mark the stream failed instead — the class's operator bool() (and the
  750|       |    // while(cdxr) / while(*this) callers) already treats this as end-of-input.
  751|      1|    obErrorLog.ThrowError(__FUNCTION__,"Invalid file, no ChemDraw Header",obError);
  752|      1|    ifs.setstate(ios::eofbit);
  753|      1|  }
  754|      1|}
_ZN9OpenBabel21ChemDrawBinaryXFormatC2Ev:
  128|      2|  {
  129|      2|    OBConversion::RegisterFormat("cdx",this);
  130|      2|  }
_ZNK9OpenBabel9CDXReadercvbEv:
  100|      2|  operator bool ()const        { return (bool)ifs; }
_ZN9OpenBabel21ChemDrawBinaryXFormat5FlagsEv:
  163|      7|  {
  164|      7|    return READBINARY|NOTWRITABLE;
  ------------------
  |  |   33|      7|#define READBINARY      0x04
  ------------------
                  return READBINARY|NOTWRITABLE;
  ------------------
  |  |   35|      7|#define NOTWRITABLE     0x10
  ------------------
  165|      7|  }

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

_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|    }

_ZN9OpenBabel9CIFFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
 1399|      1|  {
 1400|       |    // If installed, use the mmCIF parser to read CIF
 1401|      1|    OBFormat *obformat = OBFormat::FindType("mmcif");
 1402|      1|    if (obformat) { return obformat->ReadMolecule(pOb, pConv); }
  ------------------
  |  Branch (1402:9): [True: 1, False: 0]
  ------------------
 1403|      0|    obErrorLog.ThrowError(__FUNCTION__, "mmCIF parser not found. Using CIF parser.", obDebug);
 1404|       |
 1405|      0|    OBMol* pmol = dynamic_cast<OBMol*>(pOb);
 1406|      0|    if (pmol == nullptr)
  ------------------
  |  Branch (1406:9): [True: 0, False: 0]
  ------------------
 1407|      0|      return false;
 1408|       |
 1409|      0|    CIF cif(*pConv->GetInStream(),true);
 1410|       |    // Loop on all data blocks until we find one structure :@todo: handle multiple structures
 1411|      0|    for(map<string,CIFData>::iterator pos=cif.mvData.begin();pos!=cif.mvData.end();++pos)
  ------------------
  |  Branch (1411:62): [True: 0, False: 0]
  ------------------
 1412|      0|      if(pos->second.mvAtom.size()>0)
  ------------------
  |  Branch (1412:10): [True: 0, False: 0]
  ------------------
 1413|      0|        {
 1414|      0|          pmol->BeginModify();
 1415|      0|          if(pos->second.mvLatticePar.size()==6)
  ------------------
  |  Branch (1415:14): [True: 0, False: 0]
  ------------------
 1416|      0|            {// We have one unit cell
 1417|      0|              string spg=pos->second.mSpacegroupSymbolHall;
 1418|      0|              if(spg=="") spg=pos->second.mSpacegroupHermannMauguin;
  ------------------
  |  Branch (1418:18): [True: 0, False: 0]
  ------------------
 1419|      0|              if(spg=="") spg=pos->second.mSpacegroupNumberIT;
  ------------------
  |  Branch (1419:18): [True: 0, False: 0]
  ------------------
 1420|      0|              if(spg=="") spg="P1";
  ------------------
  |  Branch (1420:18): [True: 0, False: 0]
  ------------------
 1421|      0|              OBUnitCell *pCell=new OBUnitCell;
 1422|      0|              pCell->SetOrigin(fileformatInput);
 1423|      0|              pCell->SetData(pos->second.mvLatticePar[0],
 1424|      0|                             pos->second.mvLatticePar[1],
 1425|      0|                             pos->second.mvLatticePar[2],
 1426|      0|                             pos->second.mvLatticePar[3]/DEG_TO_RAD,
  ------------------
  |  |   35|      0|#define DEG_TO_RAD (M_PI/180.0)
  ------------------
 1427|      0|                             pos->second.mvLatticePar[4]/DEG_TO_RAD,
  ------------------
  |  |   35|      0|#define DEG_TO_RAD (M_PI/180.0)
  ------------------
 1428|      0|                             pos->second.mvLatticePar[5]/DEG_TO_RAD);
  ------------------
  |  |   35|      0|#define DEG_TO_RAD (M_PI/180.0)
  ------------------
 1429|      0|              pCell->SetSpaceGroup(spg);
 1430|      0|              pCell->SetSpaceGroup(pos->second.mSpaceGroup);
 1431|      0|              pmol->SetData(pCell);
 1432|      0|            }
 1433|      0|          if(pos->second.mName!="") pmol->SetTitle(pos->second.mName);
  ------------------
  |  Branch (1433:14): [True: 0, False: 0]
  ------------------
 1434|      0|          else
 1435|      0|            if(pos->second.mFormula!="") pmol->SetTitle(pos->second.mFormula);
  ------------------
  |  Branch (1435:16): [True: 0, False: 0]
  ------------------
 1436|      0|            else pmol->SetTitle(pConv->GetTitle());
 1437|       |
 1438|      0|          if(pos->second.mFormula!="") pmol->SetFormula(pos->second.mFormula);
  ------------------
  |  Branch (1438:14): [True: 0, False: 0]
  ------------------
 1439|       |
 1440|       |          // Keep a map linking the cif atom label to the obatom*, for bond interpretation later
 1441|      0|          std::map<std::string,OBAtom *> vLabelOBatom;
 1442|       |
 1443|      0|          const unsigned int nbatoms=pos->second.mvAtom.size();
 1444|      0|          pmol->ReserveAtoms(nbatoms);
 1445|      0|          for(vector<CIFData::CIFAtom>::const_iterator posat=pos->second.mvAtom.begin();posat!=pos->second.mvAtom.end();++posat)
  ------------------
  |  Branch (1445:89): [True: 0, False: 0]
  ------------------
 1446|      0|            {
 1447|       |              // Problem: posat->mSymbol is not guaranteed to actually be a symbol
 1448|       |              // see http://www.iucr.org/iucr-top/cif/cifdic_html/1/cif_core.dic/Iatom_type_symbol.html
 1449|       |              // Try to strip the string to have a better chance to have a valid symbol
 1450|       |              // This is not guaranteed to work still, as the CIF standard allows about any string...
 1451|      0|              string tmpSymbol=posat->mSymbol;
 1452|      0|              unsigned int nbc=0;
 1453|      0|              if((tmpSymbol.size()==1) && isalpha(tmpSymbol[0])) nbc=1;
  ------------------
  |  Branch (1453:18): [True: 0, False: 0]
  |  Branch (1453:43): [True: 0, False: 0]
  ------------------
 1454|      0|              else if(tmpSymbol.size()>=2)
  ------------------
  |  Branch (1454:23): [True: 0, False: 0]
  ------------------
 1455|      0|                {
 1456|      0|                  if(isalpha(tmpSymbol[0]) && isalpha(tmpSymbol[1])) nbc=2;
  ------------------
  |  Branch (1456:22): [True: 0, False: 0]
  |  Branch (1456:47): [True: 0, False: 0]
  ------------------
 1457|      0|                  else if(isalpha(tmpSymbol[0])) nbc=1;
  ------------------
  |  Branch (1457:27): [True: 0, False: 0]
  ------------------
 1458|      0|                }
 1459|       |
 1460|      0|              OBAtom *atom  = pmol->NewAtom();
 1461|       |
 1462|      0|              vLabelOBatom.insert(make_pair(posat->mLabel,atom));
 1463|       |
 1464|      0|              if(tmpSymbol.size()>nbc)
  ------------------
  |  Branch (1464:18): [True: 0, False: 0]
  ------------------
 1465|      0|                {// Try to find a formal charge in the symbol
 1466|      0|                  int charge=0;
 1467|      0|                  int sign=0;
 1468|      0|                  for(unsigned int i=nbc;i<tmpSymbol.size();++i)
  ------------------
  |  Branch (1468:42): [True: 0, False: 0]
  ------------------
 1469|      0|                    {// Use first number found as formal charge
 1470|      0|                      if(isdigit(tmpSymbol[i]) && (charge==0)) charge=atoi(tmpSymbol.substr(i,1).c_str());
  ------------------
  |  Branch (1470:26): [True: 0, False: 0]
  |  Branch (1470:51): [True: 0, False: 0]
  ------------------
 1471|      0|                      if('-'==tmpSymbol[i]) sign-=1;
  ------------------
  |  Branch (1471:26): [True: 0, False: 0]
  ------------------
 1472|      0|                      if('+'==tmpSymbol[i]) sign+=1;
  ------------------
  |  Branch (1472:26): [True: 0, False: 0]
  ------------------
 1473|      0|                    }
 1474|      0|                  if(0!=sign) // no sign, no charge
  ------------------
  |  Branch (1474:22): [True: 0, False: 0]
  ------------------
 1475|      0|                    {
 1476|      0|                      if(charge==0) charge=1;
  ------------------
  |  Branch (1476:26): [True: 0, False: 0]
  ------------------
 1477|      0|                      stringstream ss;
 1478|      0|                      ss << tmpSymbol<<" / symbol="<<tmpSymbol.substr(0,nbc)<<" charge= "<<sign*charge;
 1479|      0|                      obErrorLog.ThrowError(__FUNCTION__, ss.str(), obDebug);
 1480|      0|                      atom->SetFormalCharge(sign*charge);
 1481|      0|                    }
 1482|      0|                }
 1483|       |
 1484|      0|              if(nbc>0) tmpSymbol=tmpSymbol.substr(0,nbc);
  ------------------
  |  Branch (1484:18): [True: 0, False: 0]
  ------------------
 1485|      0|              else tmpSymbol="C";//Something went wrong, no symbol ! Default to C ??
 1486|       |
 1487|      0|              int atomicNum = OBElements::GetAtomicNum(tmpSymbol.c_str());
 1488|       |              // Test for some oxygens with subscripts
 1489|      0|              if (atomicNum == 0 && tmpSymbol[0] == 'O') {
  ------------------
  |  Branch (1489:19): [True: 0, False: 0]
  |  Branch (1489:37): [True: 0, False: 0]
  ------------------
 1490|      0|                atomicNum = 8; // e.g. Ob, OH, etc.
 1491|      0|              }
 1492|       |
 1493|      0|              atom->SetAtomicNum(atomicNum); //set atomic number, or '0' if the atom type is not recognized
 1494|      0|              atom->SetType(tmpSymbol); //set atomic number, or '0' if the atom type is not recognized
 1495|      0|              atom->SetVector(posat->mCoordCart[0],posat->mCoordCart[1],posat->mCoordCart[2]);
 1496|      0|              if(posat->mLabel.size()>0)
  ------------------
  |  Branch (1496:18): [True: 0, False: 0]
  ------------------
 1497|      0|              {
 1498|      0|                OBPairData *label = new OBPairData;
 1499|      0|                label->SetAttribute("_atom_site_label");
 1500|      0|                label->SetValue(posat->mLabel);
 1501|      0|                label->SetOrigin(fileformatInput);
 1502|      0|                atom->SetData(label);
 1503|      0|              }
 1504|       |
 1505|      0|              OBPairFloatingPoint *occup_data = new OBPairFloatingPoint;
 1506|      0|              occup_data->SetAttribute("_atom_site_occupancy");
 1507|      0|              occup_data->SetValue(posat->mOccupancy);
 1508|      0|              occup_data->SetOrigin(fileformatInput);
 1509|      0|              atom->SetData(occup_data);
 1510|       |
 1511|      0|              if( posat->mCharge != NOCHARGE )
  ------------------
  |  |   41|      0|#define NOCHARGE FLT_MAX
  ------------------
  |  Branch (1511:19): [True: 0, False: 0]
  ------------------
 1512|      0|              {
 1513|      0|                OBPairFloatingPoint *charge_data = new OBPairFloatingPoint;
 1514|      0|                charge_data->SetAttribute("input_charge");
 1515|      0|                charge_data->SetValue(posat->mCharge);
 1516|      0|                charge_data->SetOrigin(fileformatInput);
 1517|      0|                atom->SetData(charge_data);
 1518|      0|              }
 1519|      0|            }
 1520|      0|          if (!pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (1520:15): [True: 0, False: 0]
  ------------------
 1521|      0|            pmol->ConnectTheDots();
 1522|      0|          if (pConv->IsOption("B",OBConversion::INOPTIONS))
  ------------------
  |  Branch (1522:15): [True: 0, False: 0]
  ------------------
 1523|      0|            {
 1524|      0|              for(vector<CIFData::CIFBond>::const_iterator posbond=pos->second.mvBond.begin();posbond!=pos->second.mvBond.end();++posbond)
  ------------------
  |  Branch (1524:95): [True: 0, False: 0]
  ------------------
 1525|      0|                {// Add bonds present in the cif and not detected by ConnectTheDots()
 1526|      0|                  std::map<std::string,OBAtom *>::iterator posat1,posat2;
 1527|      0|                  posat1=vLabelOBatom.find(posbond->mLabel1);
 1528|      0|                  posat2=vLabelOBatom.find(posbond->mLabel2);
 1529|      0|                  if(posat1!=vLabelOBatom.end() && posat2!=vLabelOBatom.end())
  ------------------
  |  Branch (1529:22): [True: 0, False: 0]
  |  Branch (1529:22): [True: 0, False: 0]
  |  Branch (1529:52): [True: 0, False: 0]
  ------------------
 1530|      0|                    {
 1531|      0|                      stringstream ss;
 1532|      0|                      ss << "  Adding cif bond ? "<<posat1->first<<"-"<<posat2->first;
 1533|      0|                      obErrorLog.ThrowError(__FUNCTION__, ss.str(), obDebug);
 1534|      0|                      if (pmol->GetBond(posat1->second, posat2->second) == nullptr)
  ------------------
  |  Branch (1534:27): [True: 0, False: 0]
  ------------------
 1535|      0|                        {
 1536|      0|                           obErrorLog.ThrowError(__FUNCTION__, "  :Bond added !", obDebug);
 1537|      0|                           OBBond * bond=pmol->NewBond();
 1538|      0|                           bond->SetBegin(posat1->second);
 1539|      0|                           bond->SetEnd(posat2->second);
 1540|      0|                           bond->SetBondOrder(1);
 1541|      0|                           bond->SetLength(double(posbond->mDistance));
 1542|      0|                        }
 1543|      0|                       else obErrorLog.ThrowError(__FUNCTION__, "  :Bond already present.. ", obDebug);
 1544|      0|                    }
 1545|      0|                }
 1546|      0|            }
 1547|      0|          if (!pConv->IsOption("s",OBConversion::INOPTIONS) && !pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (1547:15): [True: 0, False: 0]
  |  Branch (1547:64): [True: 0, False: 0]
  ------------------
 1548|      0|            pmol->PerceiveBondOrders();
 1549|      0|          pmol->EndModify();
 1550|      0|          pmol->SetAutomaticFormalCharge(false); // we should have set formal charges
 1551|      0|          CorrectFormalCharges(pmol); // Look for lone Na -> Na+, etc.
 1552|      0|          return true;
 1553|      0|        }
 1554|       |
 1555|       |    // If we got here, no structure was found
 1556|      0|    obErrorLog.ThrowError(__FUNCTION__, "Problems reading a CIF file: no structure found !" , obWarning);
 1557|      0|    return(false);
 1558|      0|  }
_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|      2|    {
   50|      2|      return NOTREADABLE;
  ------------------
  |  |   31|      2|#define NOTREADABLE     0x01
  ------------------
   51|      2|    }

_ZN9OpenBabel17DlpolyInputReader11ParseHeaderERNSt3__113basic_istreamIcNS1_11char_traitsIcEEEERNS_5OBMolE:
  103|      2|  {
  104|       |
  105|       |    // Title line
  106|      2|    if ( ! ifs.getline(buffer,BUFF_SIZE) )
  ------------------
  |  |  771|      2|#define BUFF_SIZE 32768
  ------------------
  |  Branch (106:10): [True: 0, False: 2]
  ------------------
  107|      0|      {
  108|      0|        obErrorLog.ThrowError(__FUNCTION__, "Problem reading title line", obWarning);
  109|      0|        return false;
  110|      0|      }  
  111|      2|    title=buffer;
  112|      2|    Trim(title); // Remove leading & trailing space
  113|      2|    mol.BeginModify();
  114|      2|    mol.SetTitle(title);
  115|      2|    mol.EndModify();
  116|       |  
  117|       |    // levcfg, imcon & poss natms
  118|      2|    if ( ! ifs.getline(buffer,BUFF_SIZE) )
  ------------------
  |  |  771|      2|#define BUFF_SIZE 32768
  ------------------
  |  Branch (118:10): [True: 0, False: 2]
  ------------------
  119|      0|      {
  120|      0|        line=buffer;
  121|      0|        line="Problem reading levcfg line: " + line;
  122|      0|        obErrorLog.ThrowError(__FUNCTION__, line, obWarning);
  123|      0|        return false;
  124|      0|      }
  125|       |    
  126|      2|    tokenize(tokens, buffer, " \t\n");
  127|      2|    if ( tokens.size() < 2 || ! ( from_string<int>(levcfg, tokens.at(0), std::dec) 
  ------------------
  |  Branch (127:10): [True: 1, False: 1]
  |  Branch (127:35): [True: 0, False: 1]
  ------------------
  128|      0|                                     && from_string<int>(imcon, tokens.at(1), std::dec) ) )
  ------------------
  |  Branch (128:41): [True: 0, False: 0]
  ------------------
  129|      2|      {
  130|      2|        line=buffer;
  131|      2|        line="Problem reading keytrj line: " + line;
  132|      2|        obErrorLog.ThrowError(__FUNCTION__, line, obWarning);
  133|      2|        return false;
  134|      2|      }
  135|       |
  136|      0|    return true;
  137|       |
  138|      2|  } // End ParseHeader
_ZN9OpenBabel18DlpolyConfigFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
  299|      2|  {
  300|       |    
  301|      2|    bool ok;
  302|       |
  303|       |    // Reset data
  304|      2|    levcfg=0;
  305|      2|    imcon=0;
  306|      2|    forces.clear();
  307|       |
  308|      2|    OBMol* pmol = pOb->CastAndClear<OBMol>();
  309|      2|    if (pmol == nullptr)
  ------------------
  |  Branch (309:9): [True: 0, False: 2]
  ------------------
  310|      0|      return false;
  311|       |    
  312|       |    //Define some references so we can use the old parameter names
  313|      2|    std::istream &ifs = *pConv->GetInStream();
  314|      2|    OBMol &mol = *pmol;
  315|       |
  316|      2|    if ( ! ParseHeader( ifs, mol ) ) return false;
  ------------------
  |  Branch (316:10): [True: 2, 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|     10|    {
  285|     10|      return WRITEONEONLY;
  ------------------
  |  |   36|     10|#define WRITEONEONLY    0x20
  ------------------
  286|     10|    }
_ZN9OpenBabel19DlpolyHISTORYFormat5FlagsEv:
  416|      2|  {
  417|      2|    return NOTWRITABLE;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
  418|      2|  }
_ZN9OpenBabel17DlpolyInputReader11from_stringIiEEbRT_RKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPFRNS4_8ios_baseESE_E:
   51|      1|    {
   52|      1|      std::istringstream iss(s);
   53|      1|      return !(iss >> f >> t).fail();
   54|      1|    }

_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: 1, False: 0]
  |  Branch (140:47): [True: 0, 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|      3|  unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; }
  ------------------
  |  |   33|      3|#define READBINARY      0x04
  ------------------
                unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; }
  ------------------
  |  |   32|      3|#define READONEONLY     0x02
  ------------------
                unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; }
  ------------------
  |  |   37|      3|#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|      9|    {
  115|      9|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      9|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      9|#define WRITEONEONLY    0x20
  ------------------
  116|      9|    }

_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|      6|    {
   90|      6|      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      6|#define NOTREADABLE     0x01
  ------------------
                    return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      6|#define WRITEONEONLY    0x20
  ------------------
   91|      6|    }

_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|    }

_ZN9OpenBabel17JaguarInputFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
  242|      1|  {
  243|       |
  244|      1|    OBMol* pmol = pOb->CastAndClear<OBMol>();
  245|      1|    if (pmol == nullptr) return false;
  ------------------
  |  Branch (245:9): [True: 0, False: 1]
  ------------------
  246|       |
  247|       |    //Define some references so we can use the old parameter names
  248|      1|    istream &ifs = *pConv->GetInStream();
  249|      1|    OBMol &mol = *pmol;
  250|      1|    const char* title = pConv->GetTitle();
  251|       |
  252|      1|    char buffer[BUFF_SIZE];
  253|      1|    string str,str1;
  254|      1|    double x,y,z;
  255|      1|    unsigned int i;
  256|      1|    OBAtom *atom;
  257|      1|    vector<string> vs;
  258|       |
  259|      1|    mol.BeginModify();
  260|      1|    mol.Clear();
  261|      4|    while (ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      4|#define BUFF_SIZE 32768
  ------------------
  |  Branch (261:12): [True: 3, False: 1]
  ------------------
  262|      3|      {
  263|      3|        if (strstr(buffer, "&zmat") != nullptr)
  ------------------
  |  Branch (263:13): [True: 0, False: 3]
  ------------------
  264|      0|          {
  265|      0|            ifs.getline(buffer,BUFF_SIZE);  //   AtomLabel, X, Y, Z
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  266|      0|            tokenize(vs,buffer);
  267|      0|            while (vs.size() == 4)
  ------------------
  |  Branch (267:20): [True: 0, False: 0]
  ------------------
  268|      0|              {
  269|      0|                atom = mol.NewAtom();
  270|      0|                str = vs[0]; // Separate out the Symbol# into just Symbol ...
  271|      0|                for (i = 0;i < str.size();i++)
  ------------------
  |  Branch (271:28): [True: 0, False: 0]
  ------------------
  272|      0|                  if (isdigit(str[i]))
  ------------------
  |  Branch (272:23): [True: 0, False: 0]
  ------------------
  273|      0|                    str[i] = '\0';
  274|       |
  275|      0|                atom->SetAtomicNum(OBElements::GetAtomicNum(str.c_str()));
  276|      0|                x = atof((char*)vs[1].c_str());
  277|      0|                y = atof((char*)vs[2].c_str());
  278|      0|                z = atof((char*)vs[3].c_str());
  279|      0|                atom->SetVector(x,y,z);
  280|       |
  281|      0|                if (!ifs.getline(buffer,BUFF_SIZE)) break;
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (281:21): [True: 0, False: 0]
  ------------------
  282|      0|                tokenize(vs,buffer);
  283|      0|              }
  284|      0|          }
  285|      3|      }
  286|       |
  287|      1|    if (!pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (287:9): [True: 1, False: 0]
  ------------------
  288|      1|      mol.ConnectTheDots();
  289|      1|    if (!pConv->IsOption("s",OBConversion::INOPTIONS)
  ------------------
  |  Branch (289:9): [True: 1, False: 0]
  ------------------
  290|      1|        && !pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (290:12): [True: 1, False: 0]
  ------------------
  291|      1|      mol.PerceiveBondOrders();
  292|       |
  293|      1|    mol.EndModify();
  294|      1|    mol.SetTitle(title);
  295|      1|    return(true);
  296|      1|  }
_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|      6|    unsigned int Flags() override { return WRITEONEONLY; }
  ------------------
  |  |   36|      6|#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
  ------------------

_ZN9OpenBabel8CIFLexer10next_tokenERNS0_5TokenE:
  325|     65| {
  326|     65| token.type = CIFLexer::UnknownToken;
  327|     65| token.as_text.clear();
  328|   194k| while (token.type == CIFLexer::UnknownToken && input->good())
  ------------------
  |  Branch (328:9): [True: 194k, False: 64]
  |  Branch (328:49): [True: 194k, False: 1]
  ------------------
  329|   194k|   {
  330|   194k|   if (next_char <= ' ')
  ------------------
  |  Branch (330:8): [True: 194k, False: 64]
  ------------------
  331|   194k|     { // whitespace
  332|   194k|     advance();
  333|   194k|     }
  334|     64|   else
  335|     64|     { // i.e. not WhiteSpace
  336|     64|     switch(next_char)
  337|     64|       {
  338|       |     // Comment handling
  339|      0|     case '#':
  ------------------
  |  Branch (339:6): [True: 0, False: 64]
  ------------------
  340|      0|       do // eat comment to the end of the line
  341|      0|         {
  342|      0|         advance();
  343|      0|         } while (next_char != '\n' && input->good());
  ------------------
  |  Branch (343:19): [True: 0, False: 0]
  |  Branch (343:40): [True: 0, False: 0]
  ------------------
  344|       |       // We are now pointing at EOL or EOF
  345|      0|       break;
  346|       |     // Tag handling
  347|      0|     case '_':
  ------------------
  |  Branch (347:6): [True: 0, False: 64]
  ------------------
  348|      0|       do // read name to the next whitespace
  349|      0|         {
  350|      0|         if (next_char == '.') // combines DDL1 and DDL2 tag names
  ------------------
  |  Branch (350:14): [True: 0, False: 0]
  ------------------
  351|      0|           next_char = '_';
  352|      0|         else
  353|      0|           next_char = tolower(next_char);
  354|      0|         token.as_text.push_back((char)next_char);
  355|      0|         advance();
  356|      0|         } while (next_char > ' ' && input->good());
  ------------------
  |  Branch (356:19): [True: 0, False: 0]
  |  Branch (356:38): [True: 0, False: 0]
  ------------------
  357|       |       // We are now pointing at the next whitespace
  358|      0|       token.type = CIFLexer::TagToken;
  359|      0|       break;
  360|       |     // Quoted data handling
  361|      0|     case '"':
  ------------------
  |  Branch (361:6): [True: 0, False: 64]
  ------------------
  362|      0|       do // read name to the next quote-whitespace
  363|      0|         {
  364|      0|         advance();
  365|      0|         if (next_char == '"')
  ------------------
  |  Branch (365:14): [True: 0, False: 0]
  ------------------
  366|      0|           {
  367|      0|           while (next_char == '"')
  ------------------
  |  Branch (367:19): [True: 0, False: 0]
  ------------------
  368|      0|             {
  369|      0|             advance();
  370|      0|             if (next_char <= ' ') // whitespace
  ------------------
  |  Branch (370:18): [True: 0, False: 0]
  ------------------
  371|      0|               break;
  372|      0|             token.as_text.push_back((char)last_char);
  373|      0|             }
  374|      0|           if (next_char <= ' ') // whitespace
  ------------------
  |  Branch (374:16): [True: 0, False: 0]
  ------------------
  375|      0|             break;
  376|      0|           }
  377|      0|         token.as_text.push_back((char)next_char);
  378|      0|         } while (input->good());
  ------------------
  |  Branch (378:19): [True: 0, False: 0]
  ------------------
  379|       |       // We are now pointing at the next whitespace
  380|      0|       token.type = CIFLexer::ValueToken;
  381|      0|       break;
  382|      0|     case '\'':
  ------------------
  |  Branch (382:6): [True: 0, False: 64]
  ------------------
  383|      0|       do // read name to the next quote-whitespace
  384|      0|         {
  385|      0|         advance();
  386|      0|         if (next_char == '\'')
  ------------------
  |  Branch (386:14): [True: 0, False: 0]
  ------------------
  387|      0|           {
  388|      0|           while (next_char == '\'')
  ------------------
  |  Branch (388:19): [True: 0, False: 0]
  ------------------
  389|      0|             {
  390|      0|             advance();
  391|      0|             if (next_char <= ' ') // whitespace
  ------------------
  |  Branch (391:18): [True: 0, False: 0]
  ------------------
  392|      0|               break;
  393|      0|             token.as_text.push_back((char)last_char);
  394|      0|             }
  395|      0|           if (next_char <= ' ') // whitespace
  ------------------
  |  Branch (395:16): [True: 0, False: 0]
  ------------------
  396|      0|             break;
  397|      0|           }
  398|      0|         token.as_text.push_back((char)next_char);
  399|      0|         } while (input->good());
  ------------------
  |  Branch (399:19): [True: 0, False: 0]
  ------------------
  400|       |       // We are now pointing at the next whitespace
  401|      0|       token.type = CIFLexer::ValueToken;
  402|      0|       break;
  403|      0|     case ';':
  ------------------
  |  Branch (403:6): [True: 0, False: 64]
  ------------------
  404|      0|       if (last_char == '\n')
  ------------------
  |  Branch (404:12): [True: 0, False: 0]
  ------------------
  405|      0|         {
  406|      0|         do // read name to the next <eol>-;
  407|      0|           {
  408|      0|           advance();
  409|      0|           if (next_char == '\n')
  ------------------
  |  Branch (409:16): [True: 0, False: 0]
  ------------------
  410|      0|             {
  411|      0|             while (next_char == '\n')
  ------------------
  |  Branch (411:21): [True: 0, False: 0]
  ------------------
  412|      0|               {
  413|      0|               advance();
  414|      0|               if (next_char == ';') // end
  ------------------
  |  Branch (414:20): [True: 0, False: 0]
  ------------------
  415|      0|                 break;
  416|      0|               token.as_text.push_back((char)last_char);
  417|      0|               }
  418|      0|             if (next_char == ';') // end
  ------------------
  |  Branch (418:18): [True: 0, False: 0]
  ------------------
  419|      0|               {
  420|      0|               advance(); // go past the end
  421|      0|               break;
  422|      0|               }
  423|      0|             }
  424|      0|           token.as_text.push_back((char)next_char);
  425|      0|           } while (input->good());
  ------------------
  |  Branch (425:21): [True: 0, False: 0]
  ------------------
  426|       |         // We are now pointing at the next whitespace
  427|      0|         token.type = CIFLexer::ValueToken;
  428|      0|         break;
  429|      0|         }
  430|       |       // drop through to the default case
  431|     64|     default: // reading an un-quoted text string
  ------------------
  |  Branch (431:6): [True: 64, False: 0]
  ------------------
  432|     64|       do // read text to the next whitespace
  433|   488k|         {
  434|   488k|         token.as_text.push_back((char)next_char);
  435|   488k|         advance();
  436|   488k|         } while (next_char > ' ' && input->good());
  ------------------
  |  Branch (436:19): [True: 488k, False: 64]
  |  Branch (436:38): [True: 488k, False: 0]
  ------------------
  437|     64|       token.type = CIFLexer::ValueOrKeyToken;
  438|       |       // We are now pointing at the next whitespace
  439|     64|       break;
  440|     64|       }
  441|     64|     }
  442|   194k|   }
  443|     65| if (token.type == CIFLexer::ValueOrKeyToken)
  ------------------
  |  Branch (443:6): [True: 64, False: 1]
  ------------------
  444|     64|   {
  445|     64|   string::size_type len = token.as_text.size();
  446|     64|   if (len == 1 && token.as_text[0] == '.')
  ------------------
  |  Branch (446:8): [True: 9, False: 55]
  |  Branch (446:20): [True: 0, False: 9]
  ------------------
  447|      0|     token.type = CIFLexer::ValueToken;
  448|     64|   else if (!strncasecmp(token.as_text.c_str(), "data_", 5))
  ------------------
  |  Branch (448:13): [True: 0, False: 64]
  ------------------
  449|      0|     {
  450|      0|     token.type = CIFLexer::KeyDataToken;
  451|      0|     token.as_text.erase(0, 5);
  452|      0|     }
  453|     64|   else if (!strcasecmp(token.as_text.c_str(), "loop_"))
  ------------------
  |  Branch (453:13): [True: 0, False: 64]
  ------------------
  454|      0|     token.type = CIFLexer::KeyLoopToken;
  455|     64|   else if (!strncasecmp(token.as_text.c_str(), "save_", 5))
  ------------------
  |  Branch (455:13): [True: 0, False: 64]
  ------------------
  456|      0|     {
  457|      0|     if (len == 5)
  ------------------
  |  Branch (457:10): [True: 0, False: 0]
  ------------------
  458|      0|       {
  459|      0|       token.type = CIFLexer::KeySaveEndToken;
  460|      0|       }
  461|      0|     else
  462|      0|       {
  463|      0|       token.type = CIFLexer::KeySaveToken;
  464|      0|       token.as_text.erase(0, 5);
  465|      0|       }
  466|      0|     }
  467|     64|   else if (!strcasecmp(token.as_text.c_str(), "stop_"))
  ------------------
  |  Branch (467:13): [True: 0, False: 64]
  ------------------
  468|      0|     token.type = CIFLexer::KeyStopToken;
  469|     64|   else if (!strcasecmp(token.as_text.c_str(), "global_"))
  ------------------
  |  Branch (469:13): [True: 0, False: 64]
  ------------------
  470|      0|     token.type = CIFLexer::KeyGlobalToken;
  471|     64|   else
  472|     64|     token.type = CIFLexer::ValueToken;
  473|     64|   }
  474|     65| return token.type != CIFLexer::UnknownToken;
  475|     65| }
_ZN9OpenBabel11mmCIFFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
  494|      1| {
  495|      1|   OBMol* pmol = pOb->CastAndClear<OBMol>();
  496|      1|   if (pmol == nullptr)
  ------------------
  |  Branch (496:8): [True: 0, False: 1]
  ------------------
  497|      0|     return false;
  498|       |
  499|      1|   CIFLexer lexer(pConv->GetInStream());
  500|      1|   CIFLexer::Token token;
  501|       |
  502|      1|   typedef map<string, unsigned> CIFasymmap;
  503|      1|   CIFasymmap asym_map;
  504|      1|   string last_asym_id = "";
  505|      1|   unsigned next_asym_no = 0;
  506|      1|   bool has_residue_information = false;
  507|       |
  508|      1|   pmol->SetChainsPerceived(); // avoid perception if we are setting residues
  509|       |
  510|      1|   bool wrap_coords = pConv->IsOption("w",OBConversion::INOPTIONS);
  511|       |
  512|       |   // move to the next data block (i.e. molecule, we hope )
  513|     65|   while (lexer.next_token(token) && token.type != CIFLexer::KeyDataToken);
  ------------------
  |  Branch (513:11): [True: 64, False: 1]
  |  Branch (513:38): [True: 64, False: 0]
  ------------------
  514|      1|   if (token.type == CIFLexer::KeyDataToken)
  ------------------
  |  Branch (514:8): [True: 0, False: 1]
  ------------------
  515|      0|     { // we have found the next data block:
  516|      0|     pmol->BeginModify();
  517|      0|     pmol->SetTitle(token.as_text);
  518|      0|     bool finished = false, token_peeked = false;
  519|      0|     double cell_a = 1.0, cell_b = 1.0, cell_c = 1.0;
  520|      0|     double cell_alpha = 90.0, cell_beta = 90.0, cell_gamma = 90.0;
  521|      0|     CIFTagID::CIFDataName name_tag = CIFTagID::unread_CIFDataName;
  522|      0|     CIFTagID::CIFDataName formula_tag = CIFTagID::unread_CIFDataName;
  523|      0|     int use_cell = 0, use_fract = 0;
  524|      0|     string space_group_name("P1");
  525|      0|     SpaceGroup space_group;
  526|      0|     bool space_group_failed = false;
  527|      0|     std::map<string, double> atomic_charges;
  528|      0|     while (!finished && (token_peeked || lexer.next_token(token)))
  ------------------
  |  Branch (528:13): [True: 0, False: 0]
  |  Branch (528:27): [True: 0, False: 0]
  |  Branch (528:43): [True: 0, False: 0]
  ------------------
  529|      0|       {
  530|      0|       token_peeked = false;
  531|      0|       switch (token.type)
  532|      0|         {
  533|      0|       case CIFLexer::KeyGlobalToken:
  ------------------
  |  Branch (533:8): [True: 0, False: 0]
  ------------------
  534|       |         // We have come to the next block:
  535|      0|         if (pmol->NumAtoms() > 0)
  ------------------
  |  Branch (535:14): [True: 0, False: 0]
  ------------------
  536|      0|           { // Found a molecule, so finished
  537|      0|           finished = true;
  538|       |           // move back to the start of the global block:
  539|      0|           lexer.backup(token.as_text.size(), 'g'); // length of "global_"
  540|      0|           }
  541|      0|         else // not yet found a molecule, so go to the next data block
  542|      0|           {
  543|      0|           while (lexer.next_token(token) && token.type != CIFLexer::KeyDataToken);
  ------------------
  |  Branch (543:19): [True: 0, False: 0]
  |  Branch (543:46): [True: 0, False: 0]
  ------------------
  544|      0|           if (token.type == CIFLexer::KeyDataToken)
  ------------------
  |  Branch (544:16): [True: 0, False: 0]
  ------------------
  545|      0|             { // we have found the next data block:
  546|      0|             pmol->SetTitle(token.as_text);
  547|      0|             }
  548|      0|           }
  549|      0|         break;
  550|      0|       case CIFLexer::KeyDataToken:
  ------------------
  |  Branch (550:8): [True: 0, False: 0]
  ------------------
  551|       |         // We have come to the next data block:
  552|      0|         if (pmol->NumAtoms() > 0)
  ------------------
  |  Branch (552:14): [True: 0, False: 0]
  ------------------
  553|      0|           { // Found a molecule, so finished
  554|      0|           finished = true;
  555|       |           // move back to the start of the data block:
  556|      0|           lexer.backup(5 + token.as_text.size(), 'd'); // length of "data_<name>"
  557|      0|           }
  558|      0|         else // not yet found a molecule, so try again
  559|      0|           pmol->SetTitle(token.as_text);
  560|      0|         break;
  561|      0|       case CIFLexer::KeySaveToken:
  ------------------
  |  Branch (561:8): [True: 0, False: 0]
  ------------------
  562|      0|         { // Simply eat tokens until the save_ ending token
  563|      0|         while (lexer.next_token(token) && token.type != CIFLexer::KeySaveEndToken);
  ------------------
  |  Branch (563:17): [True: 0, False: 0]
  |  Branch (563:44): [True: 0, False: 0]
  ------------------
  564|      0|         }
  565|      0|         break;
  566|      0|       case CIFLexer::KeyLoopToken:
  ------------------
  |  Branch (566:8): [True: 0, False: 0]
  ------------------
  567|      0|         {
  568|      0|         CIFColumnList  columns;
  569|      0|         CIFTagID::CIFCatName catid = CIFTagID::unread_CIFCatName;
  570|      0|         while ( (token_peeked = lexer.next_token(token)) == true && token.type == CIFLexer::TagToken)
  ------------------
  |  Branch (570:18): [True: 0, False: 0]
  |  Branch (570:70): [True: 0, False: 0]
  ------------------
  571|      0|           { // Read in the tags
  572|      0|           CIFTagID::CIFDataName tagid = lexer.lookup_tag(token.as_text);
  573|      0|           columns.push_back(tagid);
  574|      0|           if (catid == CIFTagID::unread_CIFCatName && tagid != CIFTagID::unread_CIFDataName)
  ------------------
  |  Branch (574:16): [True: 0, False: 0]
  |  Branch (574:56): [True: 0, False: 0]
  ------------------
  575|      0|             catid = lexer.lookup_cat(tagid);
  576|      0|           }
  577|      0|         size_t column_count = columns.size();
  578|      0|         switch (catid)
  579|      0|           {
  580|      0|         case CIFTagID::atom_site:
  ------------------
  |  Branch (580:10): [True: 0, False: 0]
  ------------------
  581|      0|           {
  582|      0|           int use_cartn = 0, use_residue = 0;
  583|      0|           use_fract = 0;
  584|      0|           CIFTagID::CIFDataName atom_type_tag = CIFTagID::unread_CIFDataName;
  585|      0|           for (CIFColumnList::const_iterator colx = columns.begin(), coly = columns.end(); colx != coly; ++ colx)
  ------------------
  |  Branch (585:93): [True: 0, False: 0]
  ------------------
  586|      0|             {
  587|      0|             switch (* colx)
  588|      0|               {
  589|      0|             case CIFTagID::_atom_site_Cartn_x:
  ------------------
  |  Branch (589:14): [True: 0, False: 0]
  ------------------
  590|      0|             case CIFTagID::_atom_site_Cartn_y:
  ------------------
  |  Branch (590:14): [True: 0, False: 0]
  ------------------
  591|      0|             case CIFTagID::_atom_site_Cartn_z:
  ------------------
  |  Branch (591:14): [True: 0, False: 0]
  ------------------
  592|      0|               ++ use_cartn;
  593|      0|               break;
  594|      0|             case CIFTagID::_atom_site_fract_x:
  ------------------
  |  Branch (594:14): [True: 0, False: 0]
  ------------------
  595|      0|             case CIFTagID::_atom_site_fract_y:
  ------------------
  |  Branch (595:14): [True: 0, False: 0]
  ------------------
  596|      0|             case CIFTagID::_atom_site_fract_z:
  ------------------
  |  Branch (596:14): [True: 0, False: 0]
  ------------------
  597|      0|               ++ use_fract;
  598|      0|               break;
  599|      0|             case CIFTagID::_atom_site_label_comp_id:
  ------------------
  |  Branch (599:14): [True: 0, False: 0]
  ------------------
  600|      0|             case CIFTagID::_atom_site_label_seq_id:
  ------------------
  |  Branch (600:14): [True: 0, False: 0]
  ------------------
  601|      0|               ++ use_residue;
  602|      0|               break;
  603|      0|             case CIFTagID::_atom_site_type_symbol:
  ------------------
  |  Branch (603:14): [True: 0, False: 0]
  ------------------
  604|      0|             case CIFTagID::_atom_site_label_atom_id:
  ------------------
  |  Branch (604:14): [True: 0, False: 0]
  ------------------
  605|      0|             case CIFTagID::_atom_site_label:
  ------------------
  |  Branch (605:14): [True: 0, False: 0]
  ------------------
  606|      0|               if (atom_type_tag < (* colx))
  ------------------
  |  Branch (606:20): [True: 0, False: 0]
  ------------------
  607|      0|                 atom_type_tag = (* colx);
  608|      0|               break;
  609|      0|             default:
  ------------------
  |  Branch (609:14): [True: 0, False: 0]
  ------------------
  610|      0|               break;
  611|      0|               }
  612|      0|             }
  613|      0|           if (use_cartn)
  ------------------
  |  Branch (613:16): [True: 0, False: 0]
  ------------------
  614|      0|             {
  615|      0|             for (CIFColumnList::iterator colx = columns.begin(), coly = columns.end(); colx != coly; ++ colx)
  ------------------
  |  Branch (615:89): [True: 0, False: 0]
  ------------------
  616|      0|               if ( (* colx) >= CIFTagID::_atom_site_fract_x && (* colx) <= CIFTagID::_atom_site_fract_z)
  ------------------
  |  Branch (616:21): [True: 0, False: 0]
  |  Branch (616:65): [True: 0, False: 0]
  ------------------
  617|      0|                 (* colx) = CIFTagID::unread_CIFDataName;
  618|      0|             use_fract = 0;
  619|      0|             }
  620|      0|           size_t column_idx = 0;
  621|      0|           OBAtom * atom = nullptr;
  622|      0|           double x = 0.0, y = 0.0, z = 0.0;
  623|      0|           CIFResidueMap ResidueMap;
  624|      0|           unsigned long chain_num = 1, residue_num = 1;
  625|      0|           unsigned int nbc=0;
  626|      0|           string residue_name, atom_label, atom_mol_label, tmpSymbol;
  627|      0|           int atomicNum;
  628|      0|           OBPairData *label;
  629|      0|           while (token.type == CIFLexer::ValueToken) // Read in the Fields
  ------------------
  |  Branch (629:19): [True: 0, False: 0]
  ------------------
  630|      0|             {
  631|      0|             if (column_idx == 0)
  ------------------
  |  Branch (631:18): [True: 0, False: 0]
  ------------------
  632|      0|               {
  633|      0|               atom  = pmol->NewAtom();
  634|      0|               x = y = z = 0.0;
  635|      0|               }
  636|      0|             switch (columns[column_idx])
  637|      0|               {
  638|      0|             case CIFTagID::_atom_site_label: // The atomic label within the molecule
  ------------------
  |  Branch (638:14): [True: 0, False: 0]
  ------------------
  639|      0|               label = new OBPairData;
  640|      0|               label->SetAttribute("_atom_site_label");
  641|      0|               label->SetValue(token.as_text);
  642|      0|               label->SetOrigin(fileformatInput);
  643|      0|               atom->SetData(label);
  644|      0|               atom_mol_label.assign(token.as_text);
  645|       |
  646|      0|               if (atom_type_tag != CIFTagID::_atom_site_label)
  ------------------
  |  Branch (646:20): [True: 0, False: 0]
  ------------------
  647|      0|                 break;
  648|       |               // Else remove everything starting from the first digit
  649|       |               // and drop through to _atom_site_type_symbol
  650|      0|               if(string::npos != token.as_text.find_first_of("0123456789"))
  ------------------
  |  Branch (650:19): [True: 0, False: 0]
  ------------------
  651|      0|                 {token.as_text.erase(token.as_text.find_first_of("0123456789"), token.as_text.size());}
  652|      0|             case CIFTagID::_atom_site_type_symbol:
  ------------------
  |  Branch (652:14): [True: 0, False: 0]
  ------------------
  653|       |               // Problem: posat->mSymbol is not guaranteed to actually be a
  654|       |               // symbol see http://www.iucr.org/iucr-top/cif/cifdic_html/1/cif_core.dic/Iatom_type_symbol.html
  655|       |               // Try to strip the string to have a better chance to have a
  656|       |               // valid symbol
  657|       |               // This is not guaranteed to work still, as the CIF standard
  658|       |               // allows about any string...
  659|      0|               tmpSymbol=token.as_text.c_str();
  660|      0|               if ((tmpSymbol.size()==1) && isalpha(tmpSymbol[0]))
  ------------------
  |  Branch (660:20): [True: 0, False: 0]
  |  Branch (660:45): [True: 0, False: 0]
  ------------------
  661|      0|                 {
  662|      0|                 nbc=1;
  663|      0|                 }
  664|      0|               else if (tmpSymbol.size()>=2)
  ------------------
  |  Branch (664:25): [True: 0, False: 0]
  ------------------
  665|      0|                 {
  666|      0|                 if (isalpha(tmpSymbol[0]) && isalpha(tmpSymbol[1]))
  ------------------
  |  Branch (666:22): [True: 0, False: 0]
  |  Branch (666:47): [True: 0, False: 0]
  ------------------
  667|      0|                   {
  668|      0|                   nbc=2;
  669|      0|                   }
  670|      0|                 else if (isalpha(tmpSymbol[0]))
  ------------------
  |  Branch (670:27): [True: 0, False: 0]
  ------------------
  671|      0|                   {
  672|      0|                   nbc=1;
  673|      0|                   }
  674|      0|                 }
  675|      0|               else
  676|      0|                 {
  677|      0|                 nbc = 0;
  678|      0|                 }
  679|      0|               if (tmpSymbol.size()>nbc)
  ------------------
  |  Branch (679:20): [True: 0, False: 0]
  ------------------
  680|      0|                 {// Try to find a formal charge in the symbol
  681|      0|                 int charge=0;
  682|      0|                 int sign=0;
  683|      0|                 for(unsigned int i=nbc;i<tmpSymbol.size();++i)
  ------------------
  |  Branch (683:41): [True: 0, False: 0]
  ------------------
  684|      0|                   {// Use first number found as formal charge
  685|      0|                   if (isdigit(tmpSymbol[i]) && (charge==0))
  ------------------
  |  Branch (685:24): [True: 0, False: 0]
  |  Branch (685:49): [True: 0, False: 0]
  ------------------
  686|      0|                     {
  687|      0|                     charge=atoi(tmpSymbol.substr(i,1).c_str());
  688|      0|                     }
  689|      0|                   if ('-'==tmpSymbol[i])
  ------------------
  |  Branch (689:24): [True: 0, False: 0]
  ------------------
  690|      0|                     {
  691|      0|                     sign-=1;
  692|      0|                     }
  693|      0|                   if ('+'==tmpSymbol[i])
  ------------------
  |  Branch (693:24): [True: 0, False: 0]
  ------------------
  694|      0|                     {
  695|      0|                     sign+=1;
  696|      0|                     }
  697|      0|                   }
  698|      0|                   if (0!=sign) // no sign, no charge
  ------------------
  |  Branch (698:24): [True: 0, False: 0]
  ------------------
  699|      0|                     {
  700|      0|                     if (charge==0)
  ------------------
  |  Branch (700:26): [True: 0, False: 0]
  ------------------
  701|      0|                       {
  702|      0|                       charge=1;
  703|      0|                       }
  704|      0|                     stringstream ss;
  705|      0|                     ss<< tmpSymbol <<" / symbol="<<tmpSymbol.substr(0,nbc)
  706|      0|                       <<" charge= "<<sign*charge;
  707|      0|                     obErrorLog.ThrowError(__FUNCTION__, ss.str(), obDebug);
  708|      0|                     atom->SetFormalCharge(sign*charge);
  709|      0|                     }
  710|      0|                 }
  711|      0|               if (nbc>0)
  ------------------
  |  Branch (711:20): [True: 0, False: 0]
  ------------------
  712|      0|                 {
  713|      0|                 tmpSymbol=tmpSymbol.substr(0,nbc);
  714|      0|                 }
  715|      0|               else
  716|      0|                 {
  717|      0|                 stringstream ss;
  718|      0|                 ss<< tmpSymbol <<" / could not derive a symbol"
  719|      0|                   <<" for atomic number. Setting it to default "
  720|      0|                   <<" Xx(atomic number 0)";
  721|      0|                 obErrorLog.ThrowError(__FUNCTION__, ss.str(), obDebug);
  722|      0|                 tmpSymbol="Xx";//Something went wrong, no symbol ! Default to Xx
  723|      0|                 }
  724|      0|               atomicNum = OBElements::GetAtomicNum(tmpSymbol.c_str());
  725|       |               // Test for some oxygens with subscripts
  726|      0|               if (atomicNum == 0 && tmpSymbol[0] == 'O')
  ------------------
  |  Branch (726:20): [True: 0, False: 0]
  |  Branch (726:38): [True: 0, False: 0]
  ------------------
  727|      0|                 {
  728|      0|                 atomicNum = 8; // e.g. Ob, OH, etc.
  729|      0|                 }
  730|       |
  731|      0|               atom->SetAtomicNum(atomicNum); //set atomic number, or '0' if the atom type is not recognized
  732|      0|               atom->SetType(tmpSymbol);
  733|      0|               break;
  734|      0|             case CIFTagID::_atom_site_fract_x:
  ------------------
  |  Branch (734:14): [True: 0, False: 0]
  ------------------
  735|      0|             case CIFTagID::_atom_site_Cartn_x:
  ------------------
  |  Branch (735:14): [True: 0, False: 0]
  ------------------
  736|      0|               x = token.as_number();
  737|      0|               break;
  738|      0|             case CIFTagID::_atom_site_fract_y:
  ------------------
  |  Branch (738:14): [True: 0, False: 0]
  ------------------
  739|      0|             case CIFTagID::_atom_site_Cartn_y:
  ------------------
  |  Branch (739:14): [True: 0, False: 0]
  ------------------
  740|      0|               y = token.as_number();
  741|      0|               break;
  742|      0|             case CIFTagID::_atom_site_fract_z:
  ------------------
  |  Branch (742:14): [True: 0, False: 0]
  ------------------
  743|      0|             case CIFTagID::_atom_site_Cartn_z:
  ------------------
  |  Branch (743:14): [True: 0, False: 0]
  ------------------
  744|      0|               z = token.as_number();
  745|      0|               break;
  746|      0|             case CIFTagID::_atom_site_label_atom_id: // The atomic label within the residue
  ------------------
  |  Branch (746:14): [True: 0, False: 0]
  ------------------
  747|      0|               atom_label.assign(token.as_text);
  748|      0|               if (atom_type_tag == CIFTagID::_atom_site_label_atom_id)
  ------------------
  |  Branch (748:20): [True: 0, False: 0]
  ------------------
  749|      0|                 {
  750|      0|                 for (string::iterator posx = token.as_text.begin(), posy = token.as_text.end(); posx != posy; ++ posx)
  ------------------
  |  Branch (750:98): [True: 0, False: 0]
  ------------------
  751|      0|                   {
  752|      0|                   char c = (char)toupper(* posx);
  753|      0|                   if ( c < 'A' || c > 'Z' )
  ------------------
  |  Branch (753:25): [True: 0, False: 0]
  |  Branch (753:36): [True: 0, False: 0]
  ------------------
  754|      0|                     {
  755|      0|                     token.as_text.erase(posx, posy);
  756|      0|                     break;
  757|      0|                     }
  758|      0|                   }
  759|      0|                 atom->SetAtomicNum(OBElements::GetAtomicNum(token.as_text.c_str()));
  760|      0|                 atom->SetType(token.as_text);
  761|      0|                 }
  762|      0|               break;
  763|      0|             case CIFTagID::_atom_site_label_comp_id: // The residue abbreviation, e.g. ILE
  ------------------
  |  Branch (763:14): [True: 0, False: 0]
  ------------------
  764|      0|               residue_name.assign(token.as_text);
  765|      0|               break;
  766|      0|             case CIFTagID::_atom_site_label_entity_id: // The chain entity number of the residue, e.g. 2
  ------------------
  |  Branch (766:14): [True: 0, False: 0]
  ------------------
  767|       |    // ignored and replaced by unique id for label_asym_id
  768|      0|               break;
  769|      0|             case CIFTagID::_atom_site_label_asym_id: // The strand number of the residue
  ------------------
  |  Branch (769:14): [True: 0, False: 0]
  ------------------
  770|      0|                   if (token.as_text != last_asym_id) {
  ------------------
  |  Branch (770:24): [True: 0, False: 0]
  ------------------
  771|      0|                       CIFasymmap::const_iterator asym_it = asym_map.find(token.as_text);
  772|      0|                          if (asym_it == asym_map.end()) {
  ------------------
  |  Branch (772:31): [True: 0, False: 0]
  ------------------
  773|      0|                              ++next_asym_no;
  774|      0|                              asym_it =
  775|      0|                                  asym_map.insert(CIFasymmap::value_type(token.as_text,
  776|      0|                                                                         next_asym_no)).first;
  777|      0|                          }
  778|      0|                          chain_num = asym_it->second;
  779|      0|                          last_asym_id = token.as_text;
  780|      0|               }
  781|      0|               break;
  782|      0|             case CIFTagID::_atom_site_label_seq_id: // The sequence number of the residue, within the chain, e.g. 12
  ------------------
  |  Branch (782:14): [True: 0, False: 0]
  ------------------
  783|      0|               residue_num = token.as_unsigned();
  784|      0|               break;
  785|      0|             case CIFTagID::_atom_site_occupancy: // The occupancy of the site.
  ------------------
  |  Branch (785:14): [True: 0, False: 0]
  ------------------
  786|      0|               {
  787|      0|                 OBPairFloatingPoint * occup = new OBPairFloatingPoint;
  788|      0|                 occup->SetAttribute("_atom_site_occupancy");
  789|      0|                 double occupancy = std::max(0.0, std::min(1.0, token.as_number())); // clamp occupancy to [0.0, 1.0] bugfix  
  790|      0|                 occup->SetValue(occupancy);
  791|      0|                 occup->SetOrigin(fileformatInput);
  792|      0|                 atom->SetData(occup);
  793|      0|               }  
  794|      0|               break;
  795|      0|             case CIFTagID::unread_CIFDataName:
  ------------------
  |  Branch (795:14): [True: 0, False: 0]
  ------------------
  796|      0|             default:
  ------------------
  |  Branch (796:14): [True: 0, False: 0]
  ------------------
  797|      0|               break;
  798|      0|               }
  799|      0|             ++ column_idx;
  800|      0|             if (column_idx == column_count)
  ------------------
  |  Branch (800:18): [True: 0, False: 0]
  ------------------
  801|      0|               {
  802|      0|               atom->SetVector(x, y, z);
  803|      0|               if (use_residue == 2)
  ------------------
  |  Branch (803:20): [True: 0, False: 0]
  ------------------
  804|      0|                 {
  805|      0|                 has_residue_information = true;
  806|      0|                 CIFResidueID res_id(chain_num, residue_num);
  807|      0|                 CIFResidueMap::const_iterator resx = ResidueMap.find(res_id);
  808|      0|                 OBResidue * res;
  809|      0|                 if (resx == ResidueMap.end())
  ------------------
  |  Branch (809:22): [True: 0, False: 0]
  ------------------
  810|      0|                   {
  811|      0|                   ResidueMap[res_id] = pmol->NumResidues();
  812|      0|                   res  = pmol->NewResidue();
  813|      0|                   res->SetChainNum(chain_num);
  814|      0|                   res->SetNum(residue_num);
  815|      0|                   res->SetName(residue_name);
  816|      0|                   }
  817|      0|                 else
  818|      0|                   res = pmol->GetResidue( (* resx).second );
  819|      0|                 res->AddAtom(atom);
  820|      0|                 if (!atom_label.empty())
  ------------------
  |  Branch (820:22): [True: 0, False: 0]
  ------------------
  821|      0|                   res->SetAtomID(atom, atom_label);
  822|      0|                 unsigned long serial_no = strtoul(atom_mol_label.c_str(), nullptr, 10);
  823|      0|                 if (serial_no > 0)
  ------------------
  |  Branch (823:22): [True: 0, False: 0]
  ------------------
  824|      0|                   res->SetSerialNum(atom, serial_no);
  825|      0|                 }
  826|      0|               column_idx = 0;
  827|      0|               }
  828|      0|             token_peeked = lexer.next_token(token);
  829|      0|             }
  830|      0|           }
  831|      0|           break;
  832|      0|         case CIFTagID::symmetry_equiv:
  ------------------
  |  Branch (832:10): [True: 0, False: 0]
  ------------------
  833|      0|           {
  834|      0|           size_t column_idx = 0;
  835|      0|           while (token.type == CIFLexer::ValueToken) // Read in the Fields
  ------------------
  |  Branch (835:19): [True: 0, False: 0]
  ------------------
  836|      0|             {
  837|      0|             if ((columns[column_idx] == CIFTagID::_symmetry_equiv_pos_as_xyz)
  ------------------
  |  Branch (837:18): [True: 0, False: 0]
  ------------------
  838|      0|               && token.as_text.find(UNKNOWN_VALUE) == string::npos)
  ------------------
  |  Branch (838:19): [True: 0, False: 0]
  ------------------
  839|      0|               space_group.AddTransform(token.as_text);
  840|      0|             ++ column_idx;
  841|      0|             if (column_idx == column_count)
  ------------------
  |  Branch (841:18): [True: 0, False: 0]
  ------------------
  842|      0|               column_idx = 0;
  843|      0|             token_peeked = lexer.next_token(token);
  844|      0|             }
  845|      0|           }
  846|      0|           break;
  847|       |
  848|      0|         case CIFTagID::atom_type: //Atoms oxidations
  ------------------
  |  Branch (848:10): [True: 0, False: 0]
  ------------------
  849|      0|           {
  850|      0|           size_t column_idx = 0;
  851|      0|           string atom_label = "";
  852|      0|           double charge = 0;
  853|      0|           while (token.type == CIFLexer::ValueToken) // Read in the Fields
  ------------------
  |  Branch (853:19): [True: 0, False: 0]
  ------------------
  854|      0|             {
  855|      0|             if (columns[column_idx] == CIFTagID::_atom_type_symbol)
  ------------------
  |  Branch (855:18): [True: 0, False: 0]
  ------------------
  856|      0|               atom_label = token.as_text;
  857|      0|             if (columns[column_idx] == CIFTagID::_atom_type_oxidation_number)
  ------------------
  |  Branch (857:18): [True: 0, False: 0]
  ------------------
  858|      0|               charge = token.as_number();
  859|      0|             ++ column_idx;
  860|      0|             if (column_idx == column_count)
  ------------------
  |  Branch (860:18): [True: 0, False: 0]
  ------------------
  861|      0|             {
  862|      0|               atomic_charges[atom_label] = charge;
  863|      0|               column_idx = 0;
  864|      0|             }
  865|      0|             token_peeked = lexer.next_token(token);
  866|      0|             }
  867|      0|           }
  868|      0|           break;
  869|       |
  870|       |
  871|      0|         case CIFTagID::unread_CIFCatName:
  ------------------
  |  Branch (871:10): [True: 0, False: 0]
  ------------------
  872|      0|         default:
  ------------------
  |  Branch (872:10): [True: 0, False: 0]
  ------------------
  873|      0|           while (token.type == CIFLexer::ValueToken) // Eat the values, we don't want them
  ------------------
  |  Branch (873:19): [True: 0, False: 0]
  ------------------
  874|      0|             token_peeked = lexer.next_token(token);
  875|      0|           break;
  876|      0|           }
  877|      0|         }
  878|      0|         break;
  879|      0|       case CIFLexer::TagToken:
  ------------------
  |  Branch (879:8): [True: 0, False: 0]
  ------------------
  880|      0|         {
  881|      0|         CIFTagID::CIFDataName tag_id = lexer.lookup_tag(token.as_text);
  882|       |         // get the value
  883|      0|         lexer.next_token(token);
  884|      0|         switch (tag_id)
  885|      0|           {
  886|      0|         case CIFTagID::_cell_length_a:
  ------------------
  |  Branch (886:10): [True: 0, False: 0]
  ------------------
  887|      0|           cell_a = token.as_number();
  888|      0|           ++ use_cell;
  889|      0|           break;
  890|      0|         case CIFTagID::_cell_length_b:
  ------------------
  |  Branch (890:10): [True: 0, False: 0]
  ------------------
  891|      0|           cell_b = token.as_number();
  892|      0|           ++ use_cell;
  893|      0|           break;
  894|      0|         case CIFTagID::_cell_length_c:
  ------------------
  |  Branch (894:10): [True: 0, False: 0]
  ------------------
  895|      0|           cell_c = token.as_number();
  896|      0|           ++ use_cell;
  897|      0|           break;
  898|      0|         case CIFTagID::_cell_angle_alpha:
  ------------------
  |  Branch (898:10): [True: 0, False: 0]
  ------------------
  899|      0|           cell_alpha = token.as_number();
  900|      0|           ++ use_cell;
  901|      0|           break;
  902|      0|         case CIFTagID::_cell_angle_beta:
  ------------------
  |  Branch (902:10): [True: 0, False: 0]
  ------------------
  903|      0|           cell_beta = token.as_number();
  904|      0|           ++ use_cell;
  905|      0|           break;
  906|      0|         case CIFTagID::_cell_angle_gamma:
  ------------------
  |  Branch (906:10): [True: 0, False: 0]
  ------------------
  907|      0|           cell_gamma = token.as_number();
  908|      0|           ++ use_cell;
  909|      0|           break;
  910|      0|         case CIFTagID::_chemical_name_systematic:
  ------------------
  |  Branch (910:10): [True: 0, False: 0]
  ------------------
  911|      0|         case CIFTagID::_chemical_name_mineral:
  ------------------
  |  Branch (911:10): [True: 0, False: 0]
  ------------------
  912|      0|         case CIFTagID::_chemical_name_structure_type:
  ------------------
  |  Branch (912:10): [True: 0, False: 0]
  ------------------
  913|      0|         case CIFTagID::_chemical_name_common:
  ------------------
  |  Branch (913:10): [True: 0, False: 0]
  ------------------
  914|      0|           if (tag_id > name_tag)
  ------------------
  |  Branch (914:16): [True: 0, False: 0]
  ------------------
  915|      0|             {
  916|      0|             name_tag = tag_id;
  917|      0|             pmol->SetTitle(token.as_text);
  918|      0|             }
  919|      0|           break;
  920|      0|         case CIFTagID::_chemical_formula_analytical:
  ------------------
  |  Branch (920:10): [True: 0, False: 0]
  ------------------
  921|      0|         case CIFTagID::_chemical_formula_structural:
  ------------------
  |  Branch (921:10): [True: 0, False: 0]
  ------------------
  922|      0|         case CIFTagID::_chemical_formula_iupac:
  ------------------
  |  Branch (922:10): [True: 0, False: 0]
  ------------------
  923|      0|         case CIFTagID::_chemical_formula_moiety:
  ------------------
  |  Branch (923:10): [True: 0, False: 0]
  ------------------
  924|      0|           if (tag_id > formula_tag)
  ------------------
  |  Branch (924:16): [True: 0, False: 0]
  ------------------
  925|      0|             {
  926|      0|             formula_tag = tag_id;
  927|      0|             pmol->SetFormula(token.as_text);
  928|      0|             }
  929|      0|           break;
  930|      0|         case CIFTagID::_space_group_IT_number:
  ------------------
  |  Branch (930:10): [True: 0, False: 0]
  ------------------
  931|      0|         case CIFTagID::_symmetry_Int_Tables_number:
  ------------------
  |  Branch (931:10): [True: 0, False: 0]
  ------------------
  932|      0|           space_group_name.assign(token.as_text);
  933|      0|           space_group.SetId(atoi(space_group_name.c_str()));
  934|      0|           break;
  935|      0|         case CIFTagID::_space_group_name_Hall:
  ------------------
  |  Branch (935:10): [True: 0, False: 0]
  ------------------
  936|      0|         case CIFTagID::_symmetry_space_group_name_Hall:
  ------------------
  |  Branch (936:10): [True: 0, False: 0]
  ------------------
  937|      0|           space_group_name.assign(token.as_text);
  938|      0|           space_group.SetHallName(space_group_name.c_str());
  939|      0|           break;
  940|      0|         case CIFTagID::_space_group_name_H_M_alt:
  ------------------
  |  Branch (940:10): [True: 0, False: 0]
  ------------------
  941|      0|         case CIFTagID::_symmetry_space_group_name_H_M:
  ------------------
  |  Branch (941:10): [True: 0, False: 0]
  ------------------
  942|      0|           space_group_name.assign(token.as_text);
  943|      0|           space_group.SetHMName(space_group_name.c_str());
  944|      0|           break;
  945|      0|         case CIFTagID::_symmetry_equiv_pos_as_xyz:
  ------------------
  |  Branch (945:10): [True: 0, False: 0]
  ------------------
  946|      0|           space_group.AddTransform(token.as_text);
  947|      0|           break;
  948|      0|         default: // eat the value for this tag
  ------------------
  |  Branch (948:10): [True: 0, False: 0]
  ------------------
  949|      0|           break;
  950|      0|           }
  951|      0|         }
  952|      0|         break;
  953|      0|       case CIFLexer::KeyStopToken:
  ------------------
  |  Branch (953:8): [True: 0, False: 0]
  ------------------
  954|      0|       case CIFLexer::ValueToken:
  ------------------
  |  Branch (954:8): [True: 0, False: 0]
  ------------------
  955|      0|       default:
  ------------------
  |  Branch (955:8): [True: 0, False: 0]
  ------------------
  956|      0|         break;
  957|      0|         }
  958|      0|       }
  959|      0|     if (pmol->NumAtoms() > 0)
  ------------------
  |  Branch (959:10): [True: 0, False: 0]
  ------------------
  960|      0|       {
  961|      0|       if (use_cell >= 6)
  ------------------
  |  Branch (961:12): [True: 0, False: 0]
  ------------------
  962|      0|         {
  963|      0|         OBUnitCell * pCell = new OBUnitCell;  // No matching "delete" because it's saved in pmol->SetData
  964|      0|         pCell->SetOrigin(fileformatInput);
  965|      0|         pCell->SetData(cell_a, cell_b, cell_c,
  966|      0|                        cell_alpha,
  967|      0|                        cell_beta,
  968|      0|                        cell_gamma
  969|      0|                        );
  970|      0|         pCell->SetSpaceGroup(space_group_name);
  971|      0|         const SpaceGroup * pSpaceGroup = SpaceGroup::Find( & space_group);
  972|      0|         if (pSpaceGroup)
  ------------------
  |  Branch (972:14): [True: 0, False: 0]
  ------------------
  973|      0|           pCell->SetSpaceGroup(pSpaceGroup);
  974|      0|         else
  975|      0|           space_group_failed = true;
  976|      0|         pmol->SetData(pCell);
  977|      0|         if (use_fract)
  ------------------
  |  Branch (977:14): [True: 0, False: 0]
  ------------------
  978|      0|           {
  979|      0|           for (OBAtomIterator atom_x = pmol->BeginAtoms(), atom_y = pmol->EndAtoms(); atom_x != atom_y; ++ atom_x)
  ------------------
  |  Branch (979:88): [True: 0, False: 0]
  ------------------
  980|      0|             {
  981|      0|             OBAtom * atom = (* atom_x);
  982|      0|             if (wrap_coords)
  ------------------
  |  Branch (982:18): [True: 0, False: 0]
  ------------------
  983|      0|               atom->SetVector(pCell->FractionalToCartesian(
  984|      0|                               pCell->WrapFractionalCoordinate(atom->GetVector())));
  985|      0|             else
  986|      0|               atom->SetVector(pCell->FractionalToCartesian(atom->GetVector()));
  987|      0|             }  // Note: this is where we could keep the original fractional coordinates, e.g. in a new OBCoord class
  988|      0|           }
  989|      0|         if (pConv->IsOption("p",OBConversion::INOPTIONS))
  ------------------
  |  Branch (989:14): [True: 0, False: 0]
  ------------------
  990|      0|           pmol->SetPeriodicMol();
  991|      0|         }
  992|      0|       for (OBAtomIterator atom_x = pmol->BeginAtoms(), atom_y = pmol->EndAtoms(); atom_x != atom_y; ++atom_x )
  ------------------
  |  Branch (992:84): [True: 0, False: 0]
  ------------------
  993|      0|       {
  994|      0|         OBAtom * atom = (* atom_x);
  995|      0|         OBPairData * pd = dynamic_cast<OBPairData *>( atom->GetData( "_atom_site_label" ) );
  996|      0|         if (pd != nullptr)
  ------------------
  |  Branch (996:14): [True: 0, False: 0]
  ------------------
  997|      0|         {
  998|      0|           if( atomic_charges.count( pd->GetValue() ) > 0 )
  ------------------
  |  Branch (998:16): [True: 0, False: 0]
  ------------------
  999|      0|           {
 1000|      0|               OBPairFloatingPoint * charge_obd = new OBPairFloatingPoint;
 1001|      0|               charge_obd->SetAttribute("input_charge");
 1002|      0|               charge_obd->SetValue(atomic_charges[pd->GetValue()] );
 1003|      0|               charge_obd->SetOrigin(fileformatInput);
 1004|      0|               atom->SetData(charge_obd);
 1005|      0|           }
 1006|      0|         }
 1007|      0|       }
 1008|       |
 1009|      0|       if (!pConv->IsOption("b",OBConversion::INOPTIONS))
  ------------------
  |  Branch (1009:12): [True: 0, False: 0]
  ------------------
 1010|      0|         {
 1011|      0|         pmol->ConnectTheDots();
 1012|      0|         if (!pConv->IsOption("s",OBConversion::INOPTIONS))
  ------------------
  |  Branch (1012:14): [True: 0, False: 0]
  ------------------
 1013|      0|           pmol->PerceiveBondOrders();
 1014|      0|         }
 1015|      0|       }
 1016|       |
 1017|      0|       if (space_group_failed)
  ------------------
  |  Branch (1017:12): [True: 0, False: 0]
  ------------------
 1018|      0|       {
 1019|      0|         string transformations;
 1020|      0|         transform3dIterator ti;
 1021|      0|         const transform3d *t = space_group.BeginTransform(ti);
 1022|      0|         while(t){
  ------------------
  |  Branch (1022:16): [True: 0, False: 0]
  ------------------
 1023|      0|           transformations += t->DescribeAsString() + " ";
 1024|      0|           t = space_group.NextTransform(ti);
 1025|      0|         }
 1026|       |
 1027|      0|         OBOp* pOp = OBOp::FindType("fillUC");
 1028|      0|         if (pOp && transformations.length())
  ------------------
  |  Branch (1028:14): [True: 0, False: 0]
  |  Branch (1028:21): [True: 0, False: 0]
  ------------------
 1029|      0|         {
 1030|      0|           map<string, string> m;
 1031|      0|           m.insert(pair<string, string>("transformations", transformations));
 1032|      0|           pOp->Do(pmol, "strict", &m);
 1033|      0|         }
 1034|      0|       }
 1035|       |
 1036|      0|     pmol->EndModify();
 1037|      0|     }
 1038|      1|   if (has_residue_information)
  ------------------
  |  Branch (1038:8): [True: 0, False: 1]
  ------------------
 1039|      0|     pmol->SetChainsPerceived();
 1040|      1|   return (pmol->NumAtoms() > 0 ? true : false);
  ------------------
  |  Branch (1040:12): [True: 0, False: 1]
  ------------------
 1041|      1| }
_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|   }
_ZN9OpenBabel8CIFLexer7advanceEv:
  260|   683k|     {
  261|   683k|     last_char = next_char;
  262|   683k|     next_char = input->get();
  263|   683k|     }
_ZN9OpenBabel8CIFLexerC2EPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEE:
  251|      1|   :input(in)
  252|      1|     {
  253|      1|     last_char = 0;
  254|      1|     next_char = input->get();
  255|      1|     }

_ZN9OpenBabel14MacroModFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE:
   74|      1|  {
   75|       |
   76|      1|    OBMol* pmol = pOb->CastAndClear<OBMol>();
   77|      1|    if (pmol == nullptr)
  ------------------
  |  Branch (77:9): [True: 0, False: 1]
  ------------------
   78|      0|      return false;
   79|       |
   80|       |    //Define some references so we can use the old parameter names
   81|      1|    istream &ifs = *pConv->GetInStream();
   82|      1|    OBMol &mol = *pmol;
   83|      1|    const char* defaultTitle = pConv->GetTitle();
   84|       |
   85|       |    // Get Title
   86|      1|    char buffer[BUFF_SIZE];
   87|      1|    int natoms = 0;
   88|      1|    vector<vector<pair<int,int> > > connections;
   89|       |
   90|      1|    if (ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      1|#define BUFF_SIZE 32768
  ------------------
  |  Branch (90:9): [True: 1, False: 0]
  ------------------
   91|      1|      {
   92|      1|        vector<string> vs;
   93|      1|        tokenize(vs,buffer," \n");
   94|       |
   95|      1|        if ( !vs.empty() && vs.size() > 0)
  ------------------
  |  Branch (95:14): [True: 1, False: 0]
  |  Branch (95:29): [True: 1, False: 0]
  ------------------
   96|      1|          sscanf(buffer,"%i%*s",&natoms);
   97|       |
   98|      1|        if (natoms <= 0 || natoms >= 100000000)
  ------------------
  |  Branch (98:13): [True: 1, False: 0]
  |  Branch (98:28): [True: 0, False: 0]
  ------------------
   99|      1|          return false;
  100|       |
  101|      0|        if ( !vs.empty() && vs.size() > 1)
  ------------------
  |  Branch (101:14): [True: 0, False: 0]
  |  Branch (101:29): [True: 0, False: 0]
  ------------------
  102|      0|          mol.SetTitle(vs[1]);
  103|      0|        else
  104|      0|          {
  105|      0|            string s = defaultTitle;
  106|      0|            mol.SetTitle(defaultTitle);
  107|      0|          }
  108|      0|      }
  109|      0|    else
  110|      0|      return(false);
  111|       |
  112|      0|    mol.BeginModify();
  113|      0|    mol.ReserveAtoms(natoms);
  114|      0|    connections.resize(natoms+1);
  115|       |
  116|       |    /***********************************************************************/
  117|       |
  118|       |    // Get Type Bonds, BondOrder, X, Y, Z
  119|       |
  120|      0|    vector3 v;
  121|      0|    int i,j;
  122|      0|    OBAtom atom;
  123|       |
  124|      0|    ttab.SetFromType("MMD");
  125|      0|    for (i = 1; i <= natoms; i++)
  ------------------
  |  Branch (125:17): [True: 0, False: 0]
  ------------------
  126|      0|      {
  127|      0|        if (!ifs.getline(buffer,BUFF_SIZE))
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  |  Branch (127:13): [True: 0, False: 0]
  ------------------
  128|      0|          break;
  129|       |
  130|       |        // Initialize every field so that a short/malformed record cannot
  131|       |        // leave us reading stale stack contents (sscanf only assigns the
  132|       |        // fields it actually matches).
  133|      0|        char temp_type[10] = {0};
  134|      0|        int end[6] = {0, 0, 0, 0, 0, 0};
  135|      0|        int order[6] = {0, 0, 0, 0, 0, 0};
  136|      0|        double x = 0.0, y = 0.0, z = 0.0;
  137|      0|        double charge = 0.0;
  138|       |
  139|       |        // The record must at least provide the atom type and x/y/z
  140|       |        // coordinates (1 string + 12 ints + 3 doubles = 16 fields).
  141|      0|        int matched =
  142|      0|          sscanf(buffer,"%9s%d%d%d%d%d%d%d%d%d%d%d%d%lf%lf%lf",
  143|      0|                 temp_type,&end[0],&order[0],&end[1],&order[1],&end[2],&order[2],
  144|      0|                 &end[3], &order[3], &end[4], &order[4], &end[5], &order[5],
  145|      0|                 &x, &y, &z);
  146|      0|        if (matched < 16)
  ------------------
  |  Branch (146:13): [True: 0, False: 0]
  ------------------
  147|      0|          {
  148|      0|            obErrorLog.ThrowError(__FUNCTION__,
  149|      0|                                  "Problems reading a MacroModel file: "
  150|      0|                                  "truncated atom record.", obError);
  151|      0|            return false;
  152|      0|          }
  153|       |
  154|      0|        pair<int,int> tmp;
  155|      0|        for ( j = 0 ; j <=5 ; j++ )
  ------------------
  |  Branch (155:23): [True: 0, False: 0]
  ------------------
  156|      0|          {
  157|      0|            if ( end[j] > 0  && end[j] > i)
  ------------------
  |  Branch (157:18): [True: 0, False: 0]
  |  Branch (157:33): [True: 0, False: 0]
  ------------------
  158|      0|              {
  159|      0|                tmp.first = end[j];
  160|      0|                tmp.second = order[j];
  161|      0|                connections[i].push_back(tmp);
  162|      0|              }
  163|      0|          }
  164|       |
  165|      0|        v.SetX(x);
  166|      0|        v.SetY(y);
  167|      0|        v.SetZ(z);
  168|      0|        atom.SetVector(v);
  169|       |
  170|      0|        string str = temp_type,str1;
  171|      0|        ttab.SetToType("ATN");
  172|      0|        ttab.Translate(str1,str);
  173|      0|        atom.SetAtomicNum(atoi(str1.c_str()));
  174|      0|        ttab.SetToType("INT");
  175|      0|        ttab.Translate(str1,str);
  176|      0|        atom.SetType(str1);
  177|       |
  178|       |        // The partial charge is an optional field in columns 101-108.  Only
  179|       |        // parse it when the line actually reaches that column, otherwise leave
  180|       |        // charge at 0.0 rather than reading stale memory past the line end.
  181|      0|        if (strlen(buffer) > 101)
  ------------------
  |  Branch (181:13): [True: 0, False: 0]
  ------------------
  182|      0|          {
  183|      0|            buffer[109]='\0';
  184|      0|            sscanf(&buffer[101],"%lf", &charge);
  185|      0|          }
  186|      0|        atom.SetPartialCharge(charge);
  187|      0|        mol.AddAtom(atom);
  188|      0|      }
  189|       |
  190|      0|    for (i = 1; i <= natoms; i++)
  ------------------
  |  Branch (190:17): [True: 0, False: 0]
  ------------------
  191|      0|      for (j = 0; j < (signed)connections[i].size(); j++)
  ------------------
  |  Branch (191:19): [True: 0, False: 0]
  ------------------
  192|      0|        mol.AddBond(i, connections[i][j].first, connections[i][j].second);
  193|       |
  194|      0|    mol.EndModify();
  195|      0|    mol.SetPartialChargesPerceived();
  196|       |    // Annotate origin of partial charges
  197|      0|    OBPairData *dp = new OBPairData;
  198|      0|    dp->SetAttribute("PartialCharges");
  199|      0|    dp->SetValue("MACROMODEL");
  200|      0|    dp->SetOrigin(fileformatInput);
  201|      0|    mol.SetData(dp);
  202|       |
  203|      0|    OBBond *bond;
  204|      0|    vector<OBBond*>::iterator bi;
  205|      0|    for (bond = mol.BeginBond(bi);bond;bond = mol.NextBond(bi))
  ------------------
  |  Branch (205:35): [True: 0, False: 0]
  ------------------
  206|      0|      if (bond->GetBondOrder() == 5 && !bond->IsInRing())
  ------------------
  |  Branch (206:11): [True: 0, False: 0]
  |  Branch (206:40): [True: 0, False: 0]
  ------------------
  207|      0|        bond->SetBondOrder(1);
  208|       |
  209|      0|    if ( natoms != (signed)mol.NumAtoms() )
  ------------------
  |  Branch (209:10): [True: 0, False: 0]
  ------------------
  210|      0|      return(false);
  211|       |
  212|       |    // clean out remaining blank lines
  213|      0|    std::streampos ipos;
  214|      0|    do
  215|      0|    {
  216|      0|      ipos = ifs.tellg();
  217|      0|      ifs.getline(buffer,BUFF_SIZE);
  ------------------
  |  |  771|      0|#define BUFF_SIZE 32768
  ------------------
  218|      0|    }
  219|      0|    while(strlen(buffer) == 0 && !ifs.eof() );
  ------------------
  |  Branch (219:11): [True: 0, False: 0]
  |  Branch (219:34): [True: 0, False: 0]
  ------------------
  220|      0|    ifs.seekg(ipos);
  221|       |
  222|      0|    return(true);
  223|      0|  }
_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|      8|    {
   58|      8|      return READONEONLY;
  ------------------
  |  |   32|      8|#define READONEONLY     0x02
  ------------------
   59|      8|    }

_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|    }

_ZN9OpenBabel10MPQCFormatC2Ev:
   34|      2|    {
   35|      2|      OBConversion::RegisterFormat("mpqc",this);
   36|      2|    }
_ZN9OpenBabel15MPQCInputFormatC2Ev:
   73|      2|    {
   74|      2|      OBConversion::RegisterFormat("mpqcin",this);
   75|      2|    }
_ZN9OpenBabel10MPQCFormat5FlagsEv:
   54|      2|    {
   55|      2|      return NOTWRITABLE | READONEONLY;
  ------------------
  |  |   35|      2|#define NOTWRITABLE     0x10
  ------------------
                    return NOTWRITABLE | READONEONLY;
  ------------------
  |  |   32|      2|#define READONEONLY     0x02
  ------------------
   56|      2|    }
_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|      5|    {
   53|      5|        return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   31|      5|#define NOTREADABLE     0x01
  ------------------
                      return NOTREADABLE | WRITEONEONLY;
  ------------------
  |  |   36|      5|#define WRITEONEONLY    0x20
  ------------------
   54|      5|    }

_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|      3|  {
  173|      3|    _title = title;
  174|      3|    Trim(_title);
  175|      3|  }
_ZN9OpenBabel5OBMol8SetTitleERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  178|      2|  {
  179|      2|    _title = title;
  180|      2|    Trim(_title);
  181|      2|  }
_ZN9OpenBabel5OBMol5ClearEv:
 1455|      7|  {
 1456|      7|    if (obErrorLog.GetOutputLevel() >= obAuditMsg)
  ------------------
  |  Branch (1456:9): [True: 0, False: 7]
  ------------------
 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|      7|    unsigned int ii;
 1466|      7|    for (ii=0 ; ii<_residue.size() ; ++ii)
  ------------------
  |  Branch (1466:17): [True: 0, False: 7]
  ------------------
 1467|      0|      {
 1468|      0|        DestroyResidue(_residue[ii]);
 1469|      0|      }
 1470|      7|    _residue.clear();
 1471|       |
 1472|      7|    vector<OBAtom*>::iterator i;
 1473|      7|    vector<OBBond*>::iterator j;
 1474|      7|    for (i = _vatom.begin();i != _vatom.end();++i)
  ------------------
  |  Branch (1474:29): [True: 0, False: 7]
  ------------------
 1475|      0|      {
 1476|      0|        DestroyAtom(*i);
 1477|      0|        *i = nullptr;
 1478|      0|      }
 1479|      7|    for (j = _vbond.begin();j != _vbond.end();++j)
  ------------------
  |  Branch (1479:29): [True: 0, False: 7]
  ------------------
 1480|      0|      {
 1481|      0|        DestroyBond(*j);
 1482|      0|        *j = nullptr;
 1483|      0|      }
 1484|       |
 1485|      7|    _atomIds.clear();
 1486|      7|    _bondIds.clear();
 1487|      7|    _natoms = _nbonds = 0;
 1488|       |
 1489|       |    //clear out the multiconformer data
 1490|      7|    vector<double*>::iterator k;
 1491|      7|    for (k = _vconf.begin();k != _vconf.end();++k)
  ------------------
  |  Branch (1491:29): [True: 0, False: 7]
  ------------------
 1492|      0|      delete [] *k;
 1493|      7|    _vconf.clear();
 1494|       |
 1495|       |    //Clear flags except OB_PATTERN_STRUCTURE which is left the same
 1496|      7|    _flags &= OB_PATTERN_STRUCTURE;
  ------------------
  |  |  101|      7|#define OB_PATTERN_STRUCTURE     (1<<19)
  ------------------
 1497|       |
 1498|      7|    _c = nullptr;
 1499|      7|    _mod = 0;
 1500|       |
 1501|       |    // Clean up generic data via the base class
 1502|      7|    return(OBBase::Clear());
 1503|      7|  }
_ZN9OpenBabel5OBMol11BeginModifyEv:
 1506|      3|  {
 1507|       |    //suck coordinates from _c into _v for each atom
 1508|      3|    if (!_mod && !Empty())
  ------------------
  |  Branch (1508:9): [True: 3, False: 0]
  |  Branch (1508:18): [True: 0, False: 3]
  ------------------
 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|      3|    _mod++;
 1534|      3|  }
_ZN9OpenBabel5OBMol9EndModifyEb:
 1537|      3|  {
 1538|      3|    if (_mod == 0)
  ------------------
  |  Branch (1538:9): [True: 1, False: 2]
  ------------------
 1539|      1|      {
 1540|      1|        obErrorLog.ThrowError(__FUNCTION__, "_mod is negative - EndModify() called too many times", obDebug);
 1541|      1|        return;
 1542|      1|      }
 1543|       |
 1544|      2|    _mod--;
 1545|       |
 1546|      2|    if (_mod)
  ------------------
  |  Branch (1546:9): [True: 0, False: 2]
  ------------------
 1547|      0|      return;
 1548|       |
 1549|       |    // wipe all but whether it has aromaticity perceived, is a reaction, or has periodic boundaries enabled
 1550|      2|    if (nukePerceivedData)
  ------------------
  |  Branch (1550:9): [True: 2, False: 0]
  ------------------
 1551|      2|      _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL);
  ------------------
  |  |   77|      2|#define OB_AROMATIC_MOL          (1<<3)
  ------------------
                    _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL);
  ------------------
  |  |  107|      2|#define OB_REACTION_MOL          (1<<22)
  ------------------
                    _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL);
  ------------------
  |  |  109|      2|#define OB_PERIODIC_MOL          (1<<23)
  ------------------
 1552|       |
 1553|      2|    _c = nullptr;
 1554|       |
 1555|      2|    if (Empty())
  ------------------
  |  Branch (1555:9): [True: 2, False: 0]
  ------------------
 1556|      2|      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|     23|  {
 2756|     23|    _natoms = _nbonds = 0;
 2757|     23|    _mod = 0;
 2758|     23|    _totalCharge = 0;
 2759|     23|    _dimension = 3;
 2760|     23|    _vatom.clear();
 2761|     23|    _atomIds.clear();
 2762|     23|    _vbond.clear();
 2763|     23|    _bondIds.clear();
 2764|     23|    _vdata.clear();
 2765|     23|    _title = "";
 2766|     23|    _c = nullptr;
 2767|     23|    _flags = 0;
 2768|     23|    _vconf.clear();
 2769|     23|    _autoPartialCharge = true;
 2770|     23|    _autoFormalCharge = true;
 2771|     23|    _energy = 0.0;
 2772|     23|  }
_ZN9OpenBabel5OBMolD2Ev:
 2797|     11|  {
 2798|     11|    OBAtom    *atom;
 2799|     11|    OBBond    *bond;
 2800|     11|    OBResidue *residue;
 2801|     11|    vector<OBAtom*>::iterator i;
 2802|     11|    vector<OBBond*>::iterator j;
 2803|     11|    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|     11|    for (residue = BeginResidue(r);residue;residue = NextResidue(r))
  ------------------
  |  Branch (2806:36): [True: 0, False: 11]
  ------------------
 2807|      0|      DestroyResidue(residue);
 2808|     11|    for (atom = BeginAtom(i);atom;atom = NextAtom(i))
  ------------------
  |  Branch (2808:30): [True: 0, False: 11]
  ------------------
 2809|      0|      DestroyAtom(atom);
 2810|     11|    for (bond = BeginBond(j);bond;bond = NextBond(j))
  ------------------
  |  Branch (2810:30): [True: 0, False: 11]
  ------------------
 2811|      0|      DestroyBond(bond);
 2812|       |
 2813|       |    //clear out the multiconformer data
 2814|     11|    vector<double*>::iterator k;
 2815|     11|    for (k = _vconf.begin();k != _vconf.end();++k)
  ------------------
  |  Branch (2815:29): [True: 0, False: 11]
  ------------------
 2816|      0|      delete [] *k;
 2817|     11|    _vconf.clear();
 2818|     11|  }
_ZN9OpenBabel5OBMol14ConnectTheDotsEv:
 3004|      1|  {
 3005|      1|    if (Empty())
  ------------------
  |  Branch (3005:9): [True: 1, False: 0]
  ------------------
 3006|      1|      return;
 3007|      0|    if (_dimension != 3) return; // not useful on non-3D structures
  ------------------
  |  Branch (3007:9): [True: 0, False: 0]
  ------------------
 3008|       |
 3009|      0|    if (IsPeriodic())
  ------------------
  |  Branch (3009:9): [True: 0, False: 0]
  ------------------
 3010|      0|      obErrorLog.ThrowError(__FUNCTION__,
 3011|      0|                            "Ran OpenBabel::ConnectTheDots -- using periodic boundary conditions",
 3012|      0|                            obAuditMsg);
 3013|      0|    else
 3014|      0|      obErrorLog.ThrowError(__FUNCTION__,
 3015|      0|                            "Ran OpenBabel::ConnectTheDots", obAuditMsg);
 3016|       |
 3017|       |
 3018|      0|    int j,k,max;
 3019|      0|    double maxrad = 0;
 3020|      0|    bool unset = false;
 3021|      0|    OBAtom *atom,*nbr;
 3022|      0|    vector<OBAtom*>::iterator i;
 3023|      0|    vector<pair<OBAtom*,double> > zsortedAtoms;
 3024|      0|    vector<double> rad;
 3025|      0|    vector<int> zsorted;
 3026|      0|    vector<int> bondCount; // existing bonds (e.g., from residues in PDB)
 3027|       |
 3028|      0|    double *c = new double [NumAtoms()*3];
 3029|      0|    rad.resize(_natoms);
 3030|       |
 3031|      0|    for (j = 0, atom = BeginAtom(i) ; atom ; atom = NextAtom(i), ++j)
  ------------------
  |  Branch (3031:39): [True: 0, False: 0]
  ------------------
 3032|      0|      {
 3033|      0|        bondCount.push_back(atom->GetExplicitDegree());
 3034|       |        //don't consider atoms with a full valance already
 3035|       |        //this is both for correctness (trust existing bonds) and performance
 3036|      0|        if(atom->GetExplicitValence() >= OBElements::GetMaxBonds(atom->GetAtomicNum()))
  ------------------
  |  Branch (3036:12): [True: 0, False: 0]
  ------------------
 3037|      0|          continue;
 3038|      0|        if(atom->GetAtomicNum() == 7 && atom->GetFormalCharge() == 0 && atom->GetExplicitValence() >= 3)
  ------------------
  |  Branch (3038:12): [True: 0, False: 0]
  |  Branch (3038:41): [True: 0, False: 0]
  |  Branch (3038:73): [True: 0, False: 0]
  ------------------
 3039|      0|          continue;
 3040|      0|        (atom->GetVector()).Get(&c[j*3]);
 3041|      0|        pair<OBAtom*,double> entry(atom, atom->GetVector().z());
 3042|      0|        zsortedAtoms.push_back(entry);
 3043|      0|      }
 3044|      0|    sort(zsortedAtoms.begin(), zsortedAtoms.end(), SortAtomZ);
 3045|       |
 3046|      0|    max = zsortedAtoms.size();
 3047|       |
 3048|      0|    for ( j = 0 ; j < max ; j++ )
  ------------------
  |  Branch (3048:19): [True: 0, False: 0]
  ------------------
 3049|      0|      {
 3050|      0|        atom   = zsortedAtoms[j].first;
 3051|      0|        rad[j] = OBElements::GetCovalentRad(atom->GetAtomicNum());
 3052|      0|        maxrad = std::max(rad[j],maxrad);
 3053|      0|        zsorted.push_back(atom->GetIdx()-1);
 3054|      0|      }
 3055|       |
 3056|      0|    int idx1, idx2;
 3057|      0|    double d2,cutoff,zd;
 3058|      0|    vector3 atom1, atom2, wrapped_coords;  // Only used for periodic coords
 3059|      0|    for (j = 0 ; j < max ; ++j)
  ------------------
  |  Branch (3059:18): [True: 0, False: 0]
  ------------------
 3060|      0|      {
 3061|      0|        double maxcutoff = SQUARE(rad[j]+maxrad+0.45);
  ------------------
  |  |  783|      0|#define SQUARE(x) ((x)*(x))
  ------------------
 3062|      0|        idx1 = zsorted[j];
 3063|      0|        for (k = j + 1 ; k < max ; k++ )
  ------------------
  |  Branch (3063:26): [True: 0, False: 0]
  ------------------
 3064|      0|          {
 3065|      0|            idx2 = zsorted[k];
 3066|       |
 3067|       |            // bonded if closer than elemental Rcov + tolerance
 3068|      0|            cutoff = SQUARE(rad[j] + rad[k] + 0.45);
  ------------------
  |  |  783|      0|#define SQUARE(x) ((x)*(x))
  ------------------
 3069|       |
 3070|       |            // Use minimum image convention if the unit cell is periodic
 3071|       |            // Otherwise, use a simpler (faster) distance calculation based on raw coordinates
 3072|      0|            if (IsPeriodic())
  ------------------
  |  Branch (3072:17): [True: 0, False: 0]
  ------------------
 3073|      0|              {
 3074|      0|                atom1 = vector3(c[idx1*3], c[idx1*3+1], c[idx1*3+2]);
 3075|      0|                atom2 = vector3(c[idx2*3], c[idx2*3+1], c[idx2*3+2]);
 3076|      0|                OBUnitCell *unitCell = (OBUnitCell * ) GetData(OBGenericDataType::UnitCell);
 3077|      0|                wrapped_coords = unitCell->MinimumImageCartesian(atom1 - atom2);
 3078|      0|                d2 = wrapped_coords.length_2();
 3079|      0|              }
 3080|      0|            else
 3081|      0|              {
 3082|      0|                zd  = SQUARE(c[idx1*3+2] - c[idx2*3+2]);
  ------------------
  |  |  783|      0|#define SQUARE(x) ((x)*(x))
  ------------------
 3083|       |                // bigger than max cutoff, which is determined using largest radius,
 3084|       |                // not the radius of k (which might be small, ie H, and cause an early  termination)
 3085|       |                // since we sort by z, anything beyond k will also fail
 3086|      0|                if (zd > maxcutoff )
  ------------------
  |  Branch (3086:21): [True: 0, False: 0]
  ------------------
 3087|      0|                  break;
 3088|       |
 3089|      0|                d2  = SQUARE(c[idx1*3]   - c[idx2*3]);
  ------------------
  |  |  783|      0|#define SQUARE(x) ((x)*(x))
  ------------------
 3090|      0|                if (d2 > cutoff)
  ------------------
  |  Branch (3090:21): [True: 0, False: 0]
  ------------------
 3091|      0|                  continue; // x's bigger than cutoff
 3092|      0|                d2 += SQUARE(c[idx1*3+1] - c[idx2*3+1]);
  ------------------
  |  |  783|      0|#define SQUARE(x) ((x)*(x))
  ------------------
 3093|      0|                if (d2 > cutoff)
  ------------------
  |  Branch (3093:21): [True: 0, False: 0]
  ------------------
 3094|      0|                  continue; // x^2 + y^2 bigger than cutoff
 3095|      0|                d2 += zd;
 3096|      0|              }
 3097|       |
 3098|      0|            if (d2 > cutoff)
  ------------------
  |  Branch (3098:17): [True: 0, False: 0]
  ------------------
 3099|      0|              continue;
 3100|      0|            if (d2 < 0.16) // 0.4 * 0.4 = 0.16
  ------------------
  |  Branch (3100:17): [True: 0, False: 0]
  ------------------
 3101|      0|              continue;
 3102|       |
 3103|      0|            atom = GetAtom(idx1+1);
 3104|      0|            nbr  = GetAtom(idx2+1);
 3105|       |
 3106|      0|            if (atom->IsConnected(nbr))
  ------------------
  |  Branch (3106:17): [True: 0, False: 0]
  ------------------
 3107|      0|              continue;
 3108|       |
 3109|      0|            if (!validAdditionalBond(atom,nbr) || !validAdditionalBond(nbr, atom))
  ------------------
  |  Branch (3109:17): [True: 0, False: 0]
  |  Branch (3109:51): [True: 0, False: 0]
  ------------------
 3110|      0|              continue;
 3111|       |
 3112|      0|            AddBond(idx1+1,idx2+1,1);
 3113|      0|          }
 3114|      0|      }
 3115|       |
 3116|       |    // If between BeginModify and EndModify, coord pointers are NULL
 3117|       |    // setup molecule to handle current coordinates
 3118|       |
 3119|      0|    if (_c == nullptr)
  ------------------
  |  Branch (3119:9): [True: 0, False: 0]
  ------------------
 3120|      0|      {
 3121|      0|        _c = c;
 3122|      0|        for (atom = BeginAtom(i);atom;atom = NextAtom(i))
  ------------------
  |  Branch (3122:34): [True: 0, False: 0]
  ------------------
 3123|      0|          atom->SetCoordPtr(&_c);
 3124|      0|        _vconf.push_back(c);
 3125|      0|        unset = true;
 3126|      0|      }
 3127|       |
 3128|       |    // Cleanup -- delete long bonds that exceed max valence
 3129|      0|    OBBond *maxbond, *bond;
 3130|      0|    double maxlength;
 3131|      0|    vector<OBBond*>::iterator l, m;
 3132|      0|    int valCount;
 3133|      0|    bool changed;
 3134|      0|    BeginModify(); //prevent needless re-perception in DeleteBond
 3135|      0|    for (atom = BeginAtom(i);atom;atom = NextAtom(i))
  ------------------
  |  Branch (3135:30): [True: 0, False: 0]
  ------------------
 3136|      0|      {
 3137|      0|        while (atom->GetExplicitValence() > static_cast<unsigned int>(OBElements::GetMaxBonds(atom->GetAtomicNum()))
  ------------------
  |  Branch (3137:16): [True: 0, False: 0]
  ------------------
 3138|      0|               || atom->SmallestBondAngle() < 45.0)
  ------------------
  |  Branch (3138:19): [True: 0, False: 0]
  ------------------
 3139|      0|          {
 3140|      0|            bond = atom->BeginBond(l);
 3141|      0|            maxbond = bond;
 3142|       |            // Fix from Liu Zhiguo 2008-01-26
 3143|       |            // loop past any bonds
 3144|       |            // which existed before ConnectTheDots was called
 3145|       |            // (e.g., from PDB resdata.txt)
 3146|      0|            valCount = 0;
 3147|      0|            while (valCount < bondCount[atom->GetIdx() - 1]) {
  ------------------
  |  Branch (3147:20): [True: 0, False: 0]
  ------------------
 3148|      0|              bond = atom->NextBond(l);
 3149|       |              // timvdm: 2008-03-05
 3150|       |              // NextBond only returns NULL if the iterator l == _bonds.end().
 3151|       |              // This was casuing problems as follows:
 3152|       |              // NextBond = 0x????????
 3153|       |              // NextBond = 0x????????
 3154|       |              // NextBond = 0x????????
 3155|       |              // NextBond = 0x????????
 3156|       |              // NextBond = NULL  <-- this NULL was not detected
 3157|       |              // NextBond = 0x????????
 3158|      0|              if (!bond) // so we add an additional check
  ------------------
  |  Branch (3158:19): [True: 0, False: 0]
  ------------------
 3159|      0|                break;
 3160|      0|              maxbond = bond;
 3161|      0|              valCount++;
 3162|      0|            }
 3163|      0|            if (!bond) // no new bonds added for this atom, just skip it
  ------------------
  |  Branch (3163:17): [True: 0, False: 0]
  ------------------
 3164|      0|              break;
 3165|       |
 3166|       |            // delete bonds between hydrogens when over max valence
 3167|      0|            if (atom->GetAtomicNum() == OBElements::Hydrogen)
  ------------------
  |  Branch (3167:17): [True: 0, False: 0]
  ------------------
 3168|      0|              {
 3169|      0|                m = l;
 3170|      0|                changed = false;
 3171|      0|                for (;bond;bond = atom->NextBond(m))
  ------------------
  |  Branch (3171:23): [True: 0, False: 0]
  ------------------
 3172|      0|                  {
 3173|      0|                    if (bond->GetNbrAtom(atom)->GetAtomicNum() == OBElements::Hydrogen)
  ------------------
  |  Branch (3173:25): [True: 0, False: 0]
  ------------------
 3174|      0|                      {
 3175|      0|                        DeleteBond(bond);
 3176|      0|                        changed = true;
 3177|      0|                        break;
 3178|      0|                      }
 3179|      0|                  }
 3180|      0|                if (changed)
  ------------------
  |  Branch (3180:21): [True: 0, False: 0]
  ------------------
 3181|      0|                  {
 3182|       |                    // bond deleted, reevaluate BOSum
 3183|      0|                    continue;
 3184|      0|                  }
 3185|      0|                else
 3186|      0|                  {
 3187|       |                    // reset to first new bond
 3188|      0|                    bond = maxbond;
 3189|      0|                  }
 3190|      0|              }
 3191|       |
 3192|      0|            maxlength = maxbond->GetLength();
 3193|      0|            for (bond = atom->NextBond(l);bond;bond = atom->NextBond(l))
  ------------------
  |  Branch (3193:43): [True: 0, False: 0]
  ------------------
 3194|      0|              {
 3195|      0|                if (bond->GetLength() > maxlength)
  ------------------
  |  Branch (3195:21): [True: 0, False: 0]
  ------------------
 3196|      0|                  {
 3197|      0|                    maxbond = bond;
 3198|      0|                    maxlength = bond->GetLength();
 3199|      0|                  }
 3200|      0|              }
 3201|      0|            DeleteBond(maxbond); // delete the new bond with the longest length
 3202|      0|          }
 3203|      0|      }
 3204|      0|    EndModify();
 3205|      0|    if (unset)
  ------------------
  |  Branch (3205:9): [True: 0, False: 0]
  ------------------
 3206|      0|      {
 3207|      0|        if (_c != nullptr){
  ------------------
  |  Branch (3207:13): [True: 0, False: 0]
  ------------------
 3208|      0|          delete [] _c;
 3209|       |
 3210|       |          // Note that the above delete doesn't set _c value to nullptr
 3211|      0|          _c = nullptr;
 3212|      0|        }
 3213|       |
 3214|      0|        for (atom = BeginAtom(i);atom;atom = NextAtom(i))
  ------------------
  |  Branch (3214:34): [True: 0, False: 0]
  ------------------
 3215|      0|          atom->ClearCoordPtr();
 3216|      0|	if (_vconf.size() > 0)
  ------------------
  |  Branch (3216:6): [True: 0, False: 0]
  ------------------
 3217|      0|	  _vconf.resize(_vconf.size()-1);
 3218|      0|      }
 3219|       |
 3220|      0|    if (_c != nullptr)
  ------------------
  |  Branch (3220:9): [True: 0, False: 0]
  ------------------
 3221|      0|      delete [] c;
 3222|      0|  }
_ZN9OpenBabel5OBMol18PerceiveBondOrdersEv:
 3233|      1|  {
 3234|      1|    if (Empty())
  ------------------
  |  Branch (3234:9): [True: 1, False: 0]
  ------------------
 3235|      1|      return;
 3236|      0|    if (_dimension != 3) return; // not useful on non-3D structures
  ------------------
  |  Branch (3236:9): [True: 0, False: 0]
  ------------------
 3237|       |
 3238|      0|    obErrorLog.ThrowError(__FUNCTION__,
 3239|      0|                          "Ran OpenBabel::PerceiveBondOrders", obAuditMsg);
 3240|       |
 3241|      0|    OBAtom *atom, *b, *c;
 3242|      0|    vector3 v1, v2;
 3243|      0|    double angle;//, dist1, dist2;
 3244|      0|    vector<OBAtom*>::iterator i;
 3245|      0|    vector<OBBond*>::iterator j;//,k;
 3246|       |
 3247|       |    //  BeginModify();
 3248|       |
 3249|       |    // Pass 1: Assign estimated hybridization based on avg. angles
 3250|      0|    for (atom = BeginAtom(i);atom;atom = NextAtom(i))
  ------------------
  |  Branch (3250:30): [True: 0, False: 0]
  ------------------
 3251|      0|      {
 3252|      0|        angle = atom->AverageBondAngle();
 3253|       |
 3254|       |        //        cout << atom->GetAtomicNum() << " " << angle << endl;
 3255|       |
 3256|      0|        if (angle > 155.0)
  ------------------
  |  Branch (3256:13): [True: 0, False: 0]
  ------------------
 3257|      0|          atom->SetHyb(1);
 3258|      0|        else if (angle <= 155.0 && angle > 115.0)
  ------------------
  |  Branch (3258:18): [True: 0, False: 0]
  |  Branch (3258:36): [True: 0, False: 0]
  ------------------
 3259|      0|          atom->SetHyb(2);
 3260|       |
 3261|       |        // special case for imines
 3262|      0|        if (atom->GetAtomicNum() == OBElements::Nitrogen
  ------------------
  |  Branch (3262:13): [True: 0, False: 0]
  ------------------
 3263|      0|            && atom->ExplicitHydrogenCount() == 1
  ------------------
  |  Branch (3263:16): [True: 0, False: 0]
  ------------------
 3264|      0|            && atom->GetExplicitDegree() == 2
  ------------------
  |  Branch (3264:16): [True: 0, False: 0]
  ------------------
 3265|      0|            && angle > 109.5)
  ------------------
  |  Branch (3265:16): [True: 0, False: 0]
  ------------------
 3266|      0|          atom->SetHyb(2);
 3267|      0|        else if(atom->GetAtomicNum() == OBElements::Nitrogen
  ------------------
  |  Branch (3267:17): [True: 0, False: 0]
  ------------------
 3268|      0|            && atom->GetExplicitDegree() == 2
  ------------------
  |  Branch (3268:16): [True: 0, False: 0]
  ------------------
 3269|      0|            && atom->IsInRing()) //azete
  ------------------
  |  Branch (3269:16): [True: 0, False: 0]
  ------------------
 3270|      0|          atom->SetHyb(2);
 3271|      0|      } // pass 1
 3272|       |
 3273|       |    // Make sure upcoming calls to GetHyb() don't kill these temporary values
 3274|      0|    SetHybridizationPerceived();
 3275|       |
 3276|       |    // Pass 2: look for 5-member rings with torsions <= 7.5 degrees
 3277|       |    //         and 6-member rings with torsions <= 12 degrees
 3278|       |    //         (set all atoms with at least two bonds to sp2)
 3279|       |
 3280|      0|    vector<OBRing*> rlist;
 3281|      0|    vector<OBRing*>::iterator ringit;
 3282|      0|    vector<int> path;
 3283|      0|    double torsions = 0.0;
 3284|       |
 3285|      0|    if (!HasSSSRPerceived())
  ------------------
  |  Branch (3285:9): [True: 0, False: 0]
  ------------------
 3286|      0|      FindSSSR();
 3287|      0|    rlist = GetSSSR();
 3288|      0|    for (ringit = rlist.begin(); ringit != rlist.end(); ++ringit)
  ------------------
  |  Branch (3288:34): [True: 0, False: 0]
  ------------------
 3289|      0|      {
 3290|      0|        if ((*ringit)->Size() == 5)
  ------------------
  |  Branch (3290:13): [True: 0, False: 0]
  ------------------
 3291|      0|          {
 3292|      0|            path = (*ringit)->_path;
 3293|      0|            torsions =
 3294|      0|              ( fabs(GetTorsion(path[0], path[1], path[2], path[3])) +
 3295|      0|                fabs(GetTorsion(path[1], path[2], path[3], path[4])) +
 3296|      0|                fabs(GetTorsion(path[2], path[3], path[4], path[0])) +
 3297|      0|                fabs(GetTorsion(path[3], path[4], path[0], path[1])) +
 3298|      0|                fabs(GetTorsion(path[4], path[0], path[1], path[2])) ) / 5.0;
 3299|      0|            if (torsions <= 7.5)
  ------------------
  |  Branch (3299:17): [True: 0, False: 0]
  ------------------
 3300|      0|              {
 3301|      0|                for (unsigned int ringAtom = 0; ringAtom != path.size(); ++ringAtom)
  ------------------
  |  Branch (3301:49): [True: 0, False: 0]
  ------------------
 3302|      0|                  {
 3303|      0|                    b = GetAtom(path[ringAtom]);
 3304|       |                    // if an aromatic ring atom has valence 3, it is already set
 3305|       |                    // to sp2 because the average angles should be 120 anyway
 3306|       |                    // so only look for valence 2
 3307|      0|                    if (b->GetExplicitDegree() == 2)
  ------------------
  |  Branch (3307:25): [True: 0, False: 0]
  ------------------
 3308|      0|                      b->SetHyb(2);
 3309|      0|                  }
 3310|      0|              }
 3311|      0|          }
 3312|      0|        else if ((*ringit)->Size() == 6)
  ------------------
  |  Branch (3312:18): [True: 0, False: 0]
  ------------------
 3313|      0|          {
 3314|      0|            path = (*ringit)->_path;
 3315|      0|            torsions =
 3316|      0|              ( fabs(GetTorsion(path[0], path[1], path[2], path[3])) +
 3317|      0|                fabs(GetTorsion(path[1], path[2], path[3], path[4])) +
 3318|      0|                fabs(GetTorsion(path[2], path[3], path[4], path[5])) +
 3319|      0|                fabs(GetTorsion(path[3], path[4], path[5], path[0])) +
 3320|      0|                fabs(GetTorsion(path[4], path[5], path[0], path[1])) +
 3321|      0|                fabs(GetTorsion(path[5], path[0], path[1], path[2])) ) / 6.0;
 3322|      0|            if (torsions <= 12.0)
  ------------------
  |  Branch (3322:17): [True: 0, False: 0]
  ------------------
 3323|      0|              {
 3324|      0|                for (unsigned int ringAtom = 0; ringAtom != path.size(); ++ringAtom)
  ------------------
  |  Branch (3324:49): [True: 0, False: 0]
  ------------------
 3325|      0|                  {
 3326|      0|                    b = GetAtom(path[ringAtom]);
 3327|      0|                    if (b->GetExplicitDegree() == 2 || b->GetExplicitDegree() == 3)
  ------------------
  |  Branch (3327:25): [True: 0, False: 0]
  |  Branch (3327:56): [True: 0, False: 0]
  ------------------
 3328|      0|                      b->SetHyb(2);
 3329|      0|                  }
 3330|      0|              }
 3331|      0|          }
 3332|      0|      }
 3333|       |
 3334|       |    // Pass 3: "Antialiasing" If an atom marked as sp hybrid isn't
 3335|       |    //          bonded to another or an sp2 hybrid isn't bonded
 3336|       |    //          to another (or terminal atoms in both cases)
 3337|       |    //          mark them to a lower hybridization for now
 3338|      0|    bool openNbr;
 3339|      0|    for (atom = BeginAtom(i);atom;atom = NextAtom(i))
  ------------------
  |  Branch (3339:30): [True: 0, False: 0]
  ------------------
 3340|      0|      {
 3341|      0|        if (atom->GetHyb() == 2 || atom->GetHyb() == 1)
  ------------------
  |  Branch (3341:13): [True: 0, False: 0]
  |  Branch (3341:36): [True: 0, False: 0]
  ------------------
 3342|      0|          {
 3343|      0|            openNbr = false;
 3344|      0|            for (b = atom->BeginNbrAtom(j); b; b = atom->NextNbrAtom(j))
  ------------------
  |  Branch (3344:45): [True: 0, False: 0]
  ------------------
 3345|      0|              {
 3346|      0|                if (b->GetHyb() < 3 || b->GetExplicitDegree() == 1)
  ------------------
  |  Branch (3346:21): [True: 0, False: 0]
  |  Branch (3346:40): [True: 0, False: 0]
  ------------------
 3347|      0|                  {
 3348|      0|                    openNbr = true;
 3349|      0|                    break;
 3350|      0|                  }
 3351|      0|              }
 3352|      0|            if (!openNbr && atom->GetHyb() == 2)
  ------------------
  |  Branch (3352:17): [True: 0, False: 0]
  |  Branch (3352:29): [True: 0, False: 0]
  ------------------
 3353|      0|              atom->SetHyb(3);
 3354|      0|            else if (!openNbr && atom->GetHyb() == 1)
  ------------------
  |  Branch (3354:22): [True: 0, False: 0]
  |  Branch (3354:34): [True: 0, False: 0]
  ------------------
 3355|      0|              atom->SetHyb(2);
 3356|      0|          }
 3357|      0|      } // pass 3
 3358|       |
 3359|       |    // Pass 4: Check for known functional group patterns and assign bonds
 3360|       |    //         to the canonical form
 3361|       |    //      Currently we have explicit code to do this, but a "bond typer"
 3362|       |    //      is in progress to make it simpler to test and debug.
 3363|      0|    bondtyper.AssignFunctionalGroupBonds(*this);
 3364|       |
 3365|       |    // Pass 5: Check for aromatic rings and assign bonds as appropriate
 3366|       |    // This is just a quick and dirty approximation that marks everything
 3367|       |    //  as potentially aromatic
 3368|       |
 3369|       |    // This doesn't work perfectly, but it's pretty decent.
 3370|       |    //  Need to have a list of SMARTS patterns for common rings
 3371|       |    //  which would "break ties" on complicated multi-ring systems
 3372|       |    // (Most of the current problems lie in the interface with the
 3373|       |    //   Kekulize code anyway, not in marking everything as potentially aromatic)
 3374|       |
 3375|      0|    bool needs_kekulization = false; // are there any aromatic bonds?
 3376|      0|    bool typed; // has this ring been typed?
 3377|      0|    unsigned int loop, loopSize;
 3378|      0|    for (ringit = rlist.begin(); ringit != rlist.end(); ++ringit)
  ------------------
  |  Branch (3378:34): [True: 0, False: 0]
  ------------------
 3379|      0|      {
 3380|      0|        typed = false;
 3381|      0|        loopSize = (*ringit)->Size();
 3382|      0|        if (loopSize == 5 || loopSize == 6 || loopSize == 7)
  ------------------
  |  Branch (3382:13): [True: 0, False: 0]
  |  Branch (3382:30): [True: 0, False: 0]
  |  Branch (3382:47): [True: 0, False: 0]
  ------------------
 3383|      0|          {
 3384|      0|            path = (*ringit)->_path;
 3385|      0|            for(loop = 0; loop < loopSize; ++loop)
  ------------------
  |  Branch (3385:27): [True: 0, False: 0]
  ------------------
 3386|      0|              {
 3387|      0|                atom = GetAtom(path[loop]);
 3388|      0|                if(atom->HasBondOfOrder(2) || atom->HasBondOfOrder(3)
  ------------------
  |  Branch (3388:20): [True: 0, False: 0]
  |  Branch (3388:47): [True: 0, False: 0]
  ------------------
 3389|      0|                   || atom->GetHyb() != 2)
  ------------------
  |  Branch (3389:23): [True: 0, False: 0]
  ------------------
 3390|      0|                  {
 3391|      0|                    typed = true;
 3392|      0|                    break;
 3393|      0|                  }
 3394|      0|              }
 3395|       |
 3396|      0|            if (!typed)
  ------------------
  |  Branch (3396:17): [True: 0, False: 0]
  ------------------
 3397|      0|              for(loop = 0; loop < loopSize; ++loop)
  ------------------
  |  Branch (3397:29): [True: 0, False: 0]
  ------------------
 3398|      0|                {
 3399|       |                  //    cout << " set aromatic " << path[loop] << endl;
 3400|      0|                  (GetBond(path[loop], path[(loop+1) % loopSize]))->SetAromatic();
 3401|      0|                  needs_kekulization = true;
 3402|      0|                }
 3403|      0|          }
 3404|      0|      }
 3405|       |
 3406|       |    // Kekulization is necessary if an aromatic bond is present
 3407|      0|    if (needs_kekulization) {
  ------------------
  |  Branch (3407:9): [True: 0, False: 0]
  ------------------
 3408|      0|      this->SetAromaticPerceived();
 3409|       |      // First of all, set the atoms at the ends of the aromatic bonds to also
 3410|       |      // be aromatic. This information is required for OBKekulize.
 3411|      0|      FOR_BONDS_OF_MOL(bond, this) {
  ------------------
  |  |  418|      0|#define FOR_BONDS_OF_MOL(b,m)     for (auto b : impl::MolGetBonds(m))
  |  |  ------------------
  |  |  |  Branch (418:47): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3412|      0|        if (bond->IsAromatic()) {
  ------------------
  |  Branch (3412:13): [True: 0, False: 0]
  ------------------
 3413|      0|          bond->GetBeginAtom()->SetAromatic();
 3414|      0|          bond->GetEndAtom()->SetAromatic();
 3415|      0|        }
 3416|      0|      }
 3417|      0|      bool ok = OBKekulize(this);
 3418|      0|      if (!ok) {
  ------------------
  |  Branch (3418:11): [True: 0, False: 0]
  ------------------
 3419|      0|        stringstream errorMsg;
 3420|      0|        errorMsg << "Failed to kekulize aromatic bonds in OBMol::PerceiveBondOrders";
 3421|      0|        std::string title = this->GetTitle();
 3422|      0|        if (!title.empty())
  ------------------
  |  Branch (3422:13): [True: 0, False: 0]
  ------------------
 3423|      0|          errorMsg << " (title is " << title << ")";
 3424|      0|        errorMsg << endl;
 3425|      0|        obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning);
 3426|       |        // return false; Should we return false for a kekulization failure?
 3427|      0|      }
 3428|      0|      this->SetAromaticPerceived(false);
 3429|      0|    }
 3430|       |
 3431|       |    // Quick pass.. eliminate inter-ring sulfur atom multiple bonds
 3432|       |    // dkoes - I have removed this code - if double bonds are set,
 3433|       |    // we should trust them.  See pdb_ligands_sdf/4iph_1fj.sdf for
 3434|       |    // a case where the charge isn't set, but we break the molecule
 3435|       |    // if we remove the double bond.  Also, the previous code was
 3436|       |    // fragile - relying on the total mol charge being set.  If we
 3437|       |    // are going to do anything, we should "perceive" a formal charge
 3438|       |    // in the case of a ring sulfur with a double bond (thiopyrylium)
 3439|       |
 3440|       |    // Pass 6: Assign remaining bond types, ordered by atom electronegativity
 3441|      0|    vector<pair<OBAtom*,double> > sortedAtoms;
 3442|      0|    vector<double> rad;
 3443|      0|    vector<int> sorted;
 3444|      0|    int iter, max;
 3445|      0|    double maxElNeg, shortestBond, currentElNeg;
 3446|      0|    double bondLength, testLength;
 3447|       |
 3448|      0|    for (atom = BeginAtom(i) ; atom ; atom = NextAtom(i))
  ------------------
  |  Branch (3448:32): [True: 0, False: 0]
  ------------------
 3449|      0|      {
 3450|       |        // if atoms have the same electronegativity, make sure those with shorter bonds
 3451|       |        // are handled first (helps with assignment of conjugated single/double bonds)
 3452|      0|        shortestBond = 1.0e5;
 3453|      0|        for (b = atom->BeginNbrAtom(j); b; b = atom->NextNbrAtom(j))
  ------------------
  |  Branch (3453:41): [True: 0, False: 0]
  ------------------
 3454|      0|          {
 3455|      0|            if (b->GetAtomicNum()!=1) shortestBond =
  ------------------
  |  Branch (3455:17): [True: 0, False: 0]
  ------------------
 3456|      0|                                        std::min(shortestBond,(atom->GetBond(b))->GetLength());
 3457|      0|          }
 3458|      0|        pair<OBAtom*,double> entry(atom,
 3459|      0|                                   OBElements::GetElectroNeg(atom->GetAtomicNum())*1e6+shortestBond);
 3460|       |
 3461|      0|        sortedAtoms.push_back(entry);
 3462|      0|      }
 3463|      0|    sort(sortedAtoms.begin(), sortedAtoms.end(), SortAtomZ);
 3464|       |
 3465|      0|    max = sortedAtoms.size();
 3466|      0|    for (iter = 0 ; iter < max ; iter++ )
  ------------------
  |  Branch (3466:21): [True: 0, False: 0]
  ------------------
 3467|      0|      {
 3468|      0|        atom = sortedAtoms[iter].first;
 3469|       |        // Debugging statement
 3470|       |        //        cout << " atom->Hyb " << atom->GetAtomicNum() << " " << atom->GetIdx() << " " << atom->GetHyb()
 3471|       |        //             << " BO: " << atom->GetExplicitValence() << endl;
 3472|       |
 3473|       |        // Possible sp-hybrids
 3474|      0|        if ( (atom->GetHyb() == 1 || atom->GetExplicitDegree() == 1)
  ------------------
  |  Branch (3474:15): [True: 0, False: 0]
  |  Branch (3474:38): [True: 0, False: 0]
  ------------------
 3475|      0|             && atom->GetExplicitValence() + 2  <= static_cast<unsigned int>(OBElements::GetMaxBonds(atom->GetAtomicNum()))
  ------------------
  |  Branch (3475:17): [True: 0, False: 0]
  ------------------
 3476|      0|             )
 3477|      0|          {
 3478|       |
 3479|       |            // loop through the neighbors looking for a hybrid or terminal atom
 3480|       |            // (and pick the one with highest electronegativity first)
 3481|       |            // *or* pick a neighbor that's a terminal atom
 3482|      0|            if (atom->HasNonSingleBond() ||
  ------------------
  |  Branch (3482:17): [True: 0, False: 0]
  ------------------
 3483|      0|                (atom->GetAtomicNum() == 7 && atom->GetExplicitValence() + 2 > 3))
  ------------------
  |  Branch (3483:18): [True: 0, False: 0]
  |  Branch (3483:47): [True: 0, False: 0]
  ------------------
 3484|      0|              continue;
 3485|       |
 3486|      0|            maxElNeg = 0.0;
 3487|      0|            shortestBond = 5000.0;
 3488|      0|            c = nullptr;
 3489|      0|            for (b = atom->BeginNbrAtom(j); b; b = atom->NextNbrAtom(j))
  ------------------
  |  Branch (3489:45): [True: 0, False: 0]
  ------------------
 3490|      0|              {
 3491|      0|                currentElNeg = OBElements::GetElectroNeg(b->GetAtomicNum());
 3492|      0|                if ( (b->GetHyb() == 1 || b->GetExplicitDegree() == 1)
  ------------------
  |  Branch (3492:23): [True: 0, False: 0]
  |  Branch (3492:43): [True: 0, False: 0]
  ------------------
 3493|      0|                     && b->GetExplicitValence() + 2 <= static_cast<unsigned int>(OBElements::GetMaxBonds(b->GetAtomicNum()))
  ------------------
  |  Branch (3493:25): [True: 0, False: 0]
  ------------------
 3494|      0|                     && (currentElNeg > maxElNeg ||
  ------------------
  |  Branch (3494:26): [True: 0, False: 0]
  ------------------
 3495|      0|                         (IsApprox(currentElNeg,maxElNeg, 1.0e-6)
  ------------------
  |  Branch (3495:27): [True: 0, False: 0]
  ------------------
 3496|      0|                          && (atom->GetBond(b))->GetLength() < shortestBond)) )
  ------------------
  |  Branch (3496:30): [True: 0, False: 0]
  ------------------
 3497|      0|                  {
 3498|      0|                    if (b->HasNonSingleBond() ||
  ------------------
  |  Branch (3498:25): [True: 0, False: 0]
  ------------------
 3499|      0|                        (b->GetAtomicNum() == 7 && b->GetExplicitValence() + 2 > 3))
  ------------------
  |  Branch (3499:26): [True: 0, False: 0]
  |  Branch (3499:52): [True: 0, False: 0]
  ------------------
 3500|      0|                      continue;
 3501|       |
 3502|       |                    // Test terminal bonds against expected triple bond lengths
 3503|      0|                    bondLength = (atom->GetBond(b))->GetLength();
 3504|      0|                    if (atom->GetExplicitDegree() == 1 || b->GetExplicitDegree() == 1) {
  ------------------
  |  Branch (3504:25): [True: 0, False: 0]
  |  Branch (3504:59): [True: 0, False: 0]
  ------------------
 3505|      0|                      testLength = CorrectedBondRad(atom->GetAtomicNum(), atom->GetHyb())
 3506|      0|                        + CorrectedBondRad(b->GetAtomicNum(), b->GetHyb());
 3507|      0|                      if (bondLength > 0.9 * testLength)
  ------------------
  |  Branch (3507:27): [True: 0, False: 0]
  ------------------
 3508|      0|                        continue; // too long, ignore it
 3509|      0|                    }
 3510|       |
 3511|      0|                    shortestBond = bondLength;
 3512|      0|                    maxElNeg = OBElements::GetElectroNeg(b->GetAtomicNum());
 3513|      0|                    c = b; // save this atom for later use
 3514|      0|                  }
 3515|      0|              }
 3516|      0|            if (c)
  ------------------
  |  Branch (3516:17): [True: 0, False: 0]
  ------------------
 3517|      0|              (atom->GetBond(c))->SetBondOrder(3);
 3518|      0|          }
 3519|       |        // Possible sp2-hybrid atoms
 3520|      0|        else if ( (atom->GetHyb() == 2 || atom->GetExplicitDegree() == 1)
  ------------------
  |  Branch (3520:20): [True: 0, False: 0]
  |  Branch (3520:43): [True: 0, False: 0]
  ------------------
 3521|      0|                  && atom->GetExplicitValence() + 1 <= static_cast<unsigned int>(OBElements::GetMaxBonds(atom->GetAtomicNum())) )
  ------------------
  |  Branch (3521:22): [True: 0, False: 0]
  ------------------
 3522|      0|          {
 3523|       |            // as above
 3524|      0|            if (atom->HasNonSingleBond() ||
  ------------------
  |  Branch (3524:17): [True: 0, False: 0]
  ------------------
 3525|      0|                (atom->GetAtomicNum() == 7 && atom->GetExplicitValence() + 1 > 3))
  ------------------
  |  Branch (3525:18): [True: 0, False: 0]
  |  Branch (3525:47): [True: 0, False: 0]
  ------------------
 3526|      0|              continue;
 3527|       |
 3528|       |            // Don't build multiple bonds to ring sulfurs
 3529|       |            //  except thiopyrylium
 3530|      0|            if (atom->IsInRing() && atom->GetAtomicNum() == 16) {
  ------------------
  |  Branch (3530:17): [True: 0, False: 0]
  |  Branch (3530:37): [True: 0, False: 0]
  ------------------
 3531|      0|              if (_totalCharge > 1 && atom->GetFormalCharge() == 0)
  ------------------
  |  Branch (3531:19): [True: 0, False: 0]
  |  Branch (3531:39): [True: 0, False: 0]
  ------------------
 3532|      0|                atom->SetFormalCharge(+1);
 3533|      0|              else
 3534|      0|                continue;
 3535|      0|            }
 3536|       |
 3537|      0|            maxElNeg = 0.0;
 3538|      0|            shortestBond = 5000.0;
 3539|      0|            c = nullptr;
 3540|      0|            for (b = atom->BeginNbrAtom(j); b; b = atom->NextNbrAtom(j))
  ------------------
  |  Branch (3540:45): [True: 0, False: 0]
  ------------------
 3541|      0|              {
 3542|      0|                currentElNeg = OBElements::GetElectroNeg(b->GetAtomicNum());
 3543|      0|                if ( (b->GetHyb() == 2 || b->GetExplicitDegree() == 1)
  ------------------
  |  Branch (3543:23): [True: 0, False: 0]
  |  Branch (3543:43): [True: 0, False: 0]
  ------------------
 3544|      0|                     && b->GetExplicitValence() + 1 <= static_cast<unsigned int>(OBElements::GetMaxBonds(b->GetAtomicNum()))
  ------------------
  |  Branch (3544:25): [True: 0, False: 0]
  ------------------
 3545|      0|                     && (GetBond(atom, b))->IsDoubleBondGeometry()
  ------------------
  |  Branch (3545:25): [True: 0, False: 0]
  ------------------
 3546|      0|                     && (currentElNeg > maxElNeg || (IsApprox(currentElNeg,maxElNeg, 1.0e-6)) ) )
  ------------------
  |  Branch (3546:26): [True: 0, False: 0]
  |  Branch (3546:53): [True: 0, False: 0]
  ------------------
 3547|      0|                  {
 3548|      0|                    if (b->HasNonSingleBond() ||
  ------------------
  |  Branch (3548:25): [True: 0, False: 0]
  ------------------
 3549|      0|                        (b->GetAtomicNum() == 7 && b->GetExplicitValence() + 1 > 3))
  ------------------
  |  Branch (3549:26): [True: 0, False: 0]
  |  Branch (3549:52): [True: 0, False: 0]
  ------------------
 3550|      0|                      continue;
 3551|       |
 3552|      0|                    if (b->IsInRing() && b->GetAtomicNum() == 16) {
  ------------------
  |  Branch (3552:25): [True: 0, False: 0]
  |  Branch (3552:42): [True: 0, False: 0]
  ------------------
 3553|      0|                      if (_totalCharge > 1 && b->GetFormalCharge() == 0)
  ------------------
  |  Branch (3553:27): [True: 0, False: 0]
  |  Branch (3553:47): [True: 0, False: 0]
  ------------------
 3554|      0|                        b->SetFormalCharge(+1);
 3555|      0|                      else
 3556|      0|                        continue;
 3557|      0|                    }
 3558|       |
 3559|       |                    // Test terminal bonds against expected double bond lengths
 3560|      0|                    bondLength = (atom->GetBond(b))->GetLength();
 3561|      0|                    if (atom->GetExplicitDegree() == 1 || b->GetExplicitDegree() == 1) {
  ------------------
  |  Branch (3561:25): [True: 0, False: 0]
  |  Branch (3561:59): [True: 0, False: 0]
  ------------------
 3562|      0|                      testLength = CorrectedBondRad(atom->GetAtomicNum(), atom->GetHyb())
 3563|      0|                        + CorrectedBondRad(b->GetAtomicNum(), b->GetHyb());
 3564|      0|                      if (bondLength > 0.93 * testLength)
  ------------------
  |  Branch (3564:27): [True: 0, False: 0]
  ------------------
 3565|      0|                        continue; // too long, ignore it
 3566|      0|                    }
 3567|       |
 3568|       |                    // OK, see if this is better than the previous choice
 3569|       |                    // If it's much shorter, pick it (e.g., fulvene)
 3570|       |                    // If they're close (0.1A) then prefer the bond in the ring
 3571|      0|                    double difference = shortestBond - (atom->GetBond(b))->GetLength();
 3572|      0|                    if ( (difference > 0.1)
  ------------------
  |  Branch (3572:26): [True: 0, False: 0]
  ------------------
 3573|      0|                         || ( (difference > -0.01) &&
  ------------------
  |  Branch (3573:31): [True: 0, False: 0]
  ------------------
 3574|      0|                              ( (!atom->IsInRing() || !c || !c->IsInRing() || b->IsInRing())
  ------------------
  |  Branch (3574:34): [True: 0, False: 0]
  |  Branch (3574:55): [True: 0, False: 0]
  |  Branch (3574:61): [True: 0, False: 0]
  |  Branch (3574:79): [True: 0, False: 0]
  ------------------
 3575|      0|                                || (atom->IsInRing() && c && !c->IsInRing() && b->IsInRing()) ) ) ) {
  ------------------
  |  Branch (3575:37): [True: 0, False: 0]
  |  Branch (3575:57): [True: 0, False: 0]
  |  Branch (3575:62): [True: 0, False: 0]
  |  Branch (3575:80): [True: 0, False: 0]
  ------------------
 3576|      0|                      shortestBond = (atom->GetBond(b))->GetLength();
 3577|      0|                      maxElNeg = OBElements::GetElectroNeg(b->GetAtomicNum());
 3578|      0|                      c = b; // save this atom for later use
 3579|      0|                    } // is this bond better than previous choices
 3580|      0|                  }
 3581|      0|              } // loop through neighbors
 3582|      0|            if (c)
  ------------------
  |  Branch (3582:17): [True: 0, False: 0]
  ------------------
 3583|      0|              (atom->GetBond(c))->SetBondOrder(2);
 3584|      0|          }
 3585|      0|      } // pass 6
 3586|       |
 3587|       |    // Now let the atom typer go to work again
 3588|      0|    _flags &= (~(OB_HYBRID_MOL));
  ------------------
  |  |   85|      0|#define OB_HYBRID_MOL            (1<<8)
  ------------------
 3589|      0|    _flags &= (~(OB_AROMATIC_MOL));
  ------------------
  |  |   77|      0|#define OB_AROMATIC_MOL          (1<<3)
  ------------------
 3590|      0|    _flags &= (~(OB_ATOMTYPES_MOL));
  ------------------
  |  |   79|      0|#define OB_ATOMTYPES_MOL         (1<<4)
  ------------------
 3591|       |    //  EndModify(true); // "nuke" perceived data
 3592|       |
 3593|       |    //Set _spinMultiplicity other than zero for atoms which are hydrogen
 3594|       |    //deficient and which have implicit valency definitions (essentially the
 3595|       |    //organic subset in SMILES). There are assumed to no implicit hydrogens.
 3596|       |    //AssignSpinMultiplicity(true); // TODO: sort out radicals
 3597|      0|    }
_ZN9OpenBabel5OBMol9BeginAtomERNSt3__111__wrap_iterIPPNS_6OBAtomEEE:
 3994|     11|  {
 3995|     11|    i = _vatom.begin();
 3996|     11|    return i == _vatom.end() ? nullptr : (OBAtom*)*i;
  ------------------
  |  Branch (3996:12): [True: 11, False: 0]
  ------------------
 3997|     11|  }
_ZN9OpenBabel5OBMol9BeginBondERNSt3__111__wrap_iterIPPNS_6OBBondEEE:
 4018|     11|  {
 4019|     11|    i = _vbond.begin();
 4020|     11|    return i == _vbond.end() ? nullptr : (OBBond*)*i;
  ------------------
  |  Branch (4020:12): [True: 11, False: 0]
  ------------------
 4021|     11|  }

_ZN9OpenBabel12OBConversionC2EPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEEPNS1_13basic_ostreamIcS4_EE:
  232|     11|    pInput(nullptr), pOutput(nullptr),
  233|     11|    pInFormat(nullptr),pOutFormat(nullptr), Index(0), StartNumber(1),
  234|     11|    EndNumber(0), Count(-1), m_IsFirstInput(true), m_IsLast(true),
  235|     11|    MoreFilesToCome(false), OneObjectOnly(false), ReadyToInput(false), SkippedMolecules(false),
  236|     11|    inFormatGzip(false), outFormatGzip(false),
  237|     11|    pOb1(nullptr), wInpos(0), wInlen(0), pAuxConv(nullptr)
  238|     11|  {
  239|     11|   	SetInStream(is);
  240|     11|   	SetOutStream(os);
  241|       |
  242|       |    //These options take a parameter
  243|     11|    RegisterOptionParam("f", nullptr, 1,GENOPTIONS);
  244|     11|    RegisterOptionParam("l", nullptr, 1,GENOPTIONS);
  245|     11|  }
_ZN9OpenBabel12OBConversionD2Ev:
  313|     11|  {
  314|     11|    if(pAuxConv!=this)
  ------------------
  |  Branch (314:8): [True: 11, False: 0]
  ------------------
  315|     11|      delete pAuxConv;
  316|       |    // Free any remaining streams from convenience functions
  317|     11|    SetInStream(nullptr);
  318|     11|    SetOutStream(nullptr);
  319|       |
  320|     11|  }
_ZN9OpenBabel12OBConversion14RegisterFormatEPKcPNS_8OBFormatES2_:
  330|    320|  {
  331|    320|    return pFormat->RegisterFormat(ID, MIME);
  332|    320|  }
_ZN9OpenBabel12OBConversion11SetInStreamEPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEEb:
  337|     33|  {
  338|       |      //clear and deallocate any existing streams
  339|     43|      for(unsigned i = 0, n = ownedInStreams.size(); i < n; i++)
  ------------------
  |  Branch (339:54): [True: 10, False: 33]
  ------------------
  340|     10|      {
  341|     10|        delete ownedInStreams[i];
  342|     10|      }
  343|     33|      ownedInStreams.clear();
  344|     33|      pInput = nullptr;
  345|       |
  346|     33|      if (pIn)
  ------------------
  |  Branch (346:11): [True: 11, False: 22]
  ------------------
  347|     11|      {
  348|     11|          if(takeOwnership)
  ------------------
  |  Branch (348:14): [True: 0, False: 11]
  ------------------
  349|      0|              ownedInStreams.push_back(pIn);
  350|     11|          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|     11|          if(pInFormat && !(pInFormat->Flags() & (READBINARY | READXML)) &&
  ------------------
  |  |   33|     11|#define READBINARY      0x04
  ------------------
                        if(pInFormat && !(pInFormat->Flags() & (READBINARY | READXML)) &&
  ------------------
  |  |   38|     11|#define READXML         0x80
  ------------------
  |  Branch (361:14): [True: 11, False: 0]
  |  Branch (361:27): [True: 10, False: 1]
  ------------------
  362|     10|              pIn != &std::cin) //avoid filtering stdin as well
  ------------------
  |  Branch (362:15): [True: 10, False: 0]
  ------------------
  363|     10|          {
  364|     10|            LEInStream *leIn = new LEInStream(*pInput);
  365|     10|            ownedInStreams.push_back(leIn);
  366|     10|            pInput = leIn;
  367|     10|          }
  368|     11|      }
  369|     33|  }
_ZN9OpenBabel12OBConversion12SetOutStreamEPNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEb:
  377|     33|  {
  378|       |    //clear and deallocate any existing streams
  379|     33|    for (unsigned i = 0, n = ownedOutStreams.size(); i < n; i++)
  ------------------
  |  Branch (379:54): [True: 0, False: 33]
  ------------------
  380|      0|    {
  381|      0|      delete ownedOutStreams[i];
  382|      0|    }
  383|     33|    ownedOutStreams.clear();
  384|     33|    pOutput = nullptr;
  385|       |
  386|     33|    if (pOut)
  ------------------
  |  Branch (386:9): [True: 11, False: 22]
  ------------------
  387|     11|    {
  388|     11|      if (takeOwnership)
  ------------------
  |  Branch (388:11): [True: 0, False: 11]
  ------------------
  389|      0|        ownedOutStreams.push_back(pOut);
  390|     11|      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|     11|    }
  403|     33|  }
_ZN9OpenBabel12OBConversion11SetInFormatEPKcb:
  439|     11|  {
  440|     11|    inFormatGzip = gzip;
  441|     11|    if(inID)
  ------------------
  |  Branch (441:8): [True: 11, False: 0]
  ------------------
  442|     11|      pInFormat = FindFormat(inID);
  443|     11|    return pInFormat && !(pInFormat->Flags() & NOTREADABLE);
  ------------------
  |  |   31|     11|#define NOTREADABLE     0x01
  ------------------
  |  Branch (443:12): [True: 11, False: 0]
  |  Branch (443:25): [True: 7, False: 4]
  ------------------
  444|     11|  }
_ZN9OpenBabel12OBConversion12SetOutFormatEPKcb:
  448|     11|  {
  449|     11|    outFormatGzip = gzip;
  450|     11|    if(outID)
  ------------------
  |  Branch (450:8): [True: 11, False: 0]
  ------------------
  451|     11|      pOutFormat= FindFormat(outID);
  452|     11|    return pOutFormat && !(pOutFormat->Flags() & NOTWRITABLE);
  ------------------
  |  |   35|     11|#define NOTWRITABLE     0x10
  ------------------
  |  Branch (452:12): [True: 11, False: 0]
  |  Branch (452:26): [True: 10, False: 1]
  ------------------
  453|     11|  }
_ZN9OpenBabel12OBConversion7ConvertEPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEEPNS1_13basic_ostreamIcS4_EE:
  459|     11|  {
  460|     11|    StreamState savedIn, savedOut;
  461|     11|    if (is)
  ------------------
  |  Branch (461:9): [True: 11, False: 0]
  ------------------
  462|     11|    {
  463|       |#ifdef HAVE_LIBZ
  464|       |      if(!inFormatGzip && pInFormat && zlib_stream::isGZip(*is))
  465|       |      {
  466|       |        inFormatGzip = true;
  467|       |      }
  468|       |#endif
  469|     11|      savedIn.pushInput(*this);
  470|     11|      SetInStream(is, false);
  471|     11|    }
  472|       |
  473|     11|    if (os)
  ------------------
  |  Branch (473:9): [True: 11, False: 0]
  ------------------
  474|     11|    {
  475|     11|      savedOut.pushOutput(*this);
  476|     11|      SetOutStream(os, false);
  477|     11|    }
  478|       |
  479|     11|    int count = Convert();
  480|       |
  481|     11|    if(savedIn.isSet()) savedIn.popInput(*this);
  ------------------
  |  Branch (481:8): [True: 0, False: 11]
  ------------------
  482|     11|    if(savedOut.isSet()) savedOut.popOutput(*this);
  ------------------
  |  Branch (482:8): [True: 0, False: 11]
  ------------------
  483|       |
  484|     11|    return count;
  485|     11|  }
_ZN9OpenBabel12OBConversion7ConvertEv:
  507|     11|  {
  508|     11|    if (pInput == nullptr)
  ------------------
  |  Branch (508:9): [True: 0, False: 11]
  ------------------
  509|      0|      {
  510|      0|        obErrorLog.ThrowError(__FUNCTION__, "input or output stream not set", obError);
  511|      0|        return 0;
  512|      0|      }
  513|       |
  514|     11|    if(!pInFormat) return 0;
  ------------------
  |  Branch (514:8): [True: 0, False: 11]
  ------------------
  515|     11|    Count=0;//number objects processed
  516|       |
  517|     11|    if(!SetStartAndEnd())
  ------------------
  |  Branch (517:8): [True: 0, False: 11]
  ------------------
  518|      0|      return 0;
  519|       |
  520|     11|    ReadyToInput=true;
  521|     11|    m_IsLast=false;
  522|     11|    pOb1=nullptr;
  523|     11|    wInlen=0;
  524|       |
  525|     11|    if(pInFormat->Flags() & READONEONLY)
  ------------------
  |  |   32|     11|#define READONEONLY     0x02
  ------------------
  |  Branch (525:8): [True: 1, False: 10]
  ------------------
  526|      1|      OneObjectOnly=true;
  527|       |
  528|       |    //Input loop
  529|     13|    while(ReadyToInput && pInput->good()) //Possible to omit? && pInStream->peek() != EOF
  ------------------
  |  Branch (529:11): [True: 13, False: 0]
  |  Branch (529:27): [True: 11, False: 2]
  ------------------
  530|     11|      {
  531|     11|        if(pInput==&cin)
  ------------------
  |  Branch (531:12): [True: 0, False: 11]
  ------------------
  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|     11|        else
  541|     11|          rInpos = pInput->tellg();
  542|     11|        bool ret=false;
  543|     11|#ifndef DONT_CATCH_EXCEPTIONS
  544|     11|       try
  545|     11|#endif
  546|     11|          {
  547|     11|            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|     11|            SetFirstInput(false);
  577|     11|          }
  578|     11|#ifndef DONT_CATCH_EXCEPTIONS
  579|     11|        catch(...)
  580|     11|          {
  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|     11|        if(!ret)
  ------------------
  |  Branch (589:12): [True: 9, False: 2]
  ------------------
  590|      9|          {
  591|       |            //error or termination request: terminate unless
  592|       |            // -e option requested and successfully can skip past current object
  593|      9|            if(!IsOption("e", GENOPTIONS) || pInFormat->SkipObjects(0,this)!=1)
  ------------------
  |  Branch (593:16): [True: 9, False: 0]
  |  Branch (593:46): [True: 0, False: 0]
  ------------------
  594|      9|              break;
  595|      9|          }
  596|      2|        if(OneObjectOnly)
  ------------------
  |  Branch (596:12): [True: 0, False: 2]
  ------------------
  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|      2|      }
  602|       |
  603|       |    //Output last object
  604|     11|    m_IsLast= !MoreFilesToCome;
  605|       |
  606|       |    //Output is always occurs at the end with the --OutputAtEnd option
  607|     11|    bool oae = IsOption("OutputAtEnd", GENOPTIONS) != nullptr;
  608|     11|    if(pOutFormat && (!oae || m_IsLast))
  ------------------
  |  Branch (608:8): [True: 11, False: 0]
  |  Branch (608:23): [True: 11, False: 0]
  |  Branch (608:31): [True: 0, False: 0]
  ------------------
  609|     11|      if((oae || pOb1) && !pOutFormat->WriteChemObject(this))
  ------------------
  |  Branch (609:11): [True: 0, False: 11]
  |  Branch (609:18): [True: 0, False: 11]
  |  Branch (609:27): [True: 0, False: 0]
  ------------------
  610|      0|        Index--;
  611|       |
  612|       |    //Put AddChemObject() into non-queue mode
  613|     11|    Count= -1;
  614|     11|    EndNumber=StartNumber=0; pOb1=nullptr; //leave tidy
  615|     11|    MoreFilesToCome=false;
  616|     11|    OneObjectOnly=false;
  617|       |
  618|     11|    return Index; //The number actually output
  619|     11|  }
_ZN9OpenBabel12OBConversion14SetStartAndEndEv:
  622|     11|  {
  623|     11|    unsigned int TempStartNumber=0;
  624|     11|    const char* p = IsOption("f",GENOPTIONS);
  625|     11|    if(p)
  ------------------
  |  Branch (625:8): [True: 0, False: 11]
  ------------------
  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|     11|    p = IsOption("l",GENOPTIONS);
  644|     11|    if(p)
  ------------------
  |  Branch (644:8): [True: 0, False: 11]
  ------------------
  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|     11|    return true;
  652|     11|  }
_ZN9OpenBabel12OBConversion13AddChemObjectEPNS_6OBBaseE:
  676|      2|  {
  677|      2|    if(Count<0)
  ------------------
  |  Branch (677:8): [True: 0, False: 2]
  ------------------
  678|      0|      {
  679|      0|        pOb1=pOb;
  680|      0|        return Count; // <0
  681|      0|      }
  682|      2|    Count++;
  683|      2|    if(Count>=(int)StartNumber)//keeps reading objects but does nothing with them
  ------------------
  |  Branch (683:8): [True: 2, False: 0]
  ------------------
  684|      2|      {
  685|      2|        if(Count==(int)EndNumber)
  ------------------
  |  Branch (685:12): [True: 0, False: 2]
  ------------------
  686|      0|          ReadyToInput=false; //stops any more objects being read
  687|       |
  688|      2|        rInlen = pInput ? pInput->tellg() - rInpos : 0;
  ------------------
  |  Branch (688:18): [True: 2, False: 0]
  ------------------
  689|       |         // - (pLineEndBuf ? pLineEndBuf->getCorrection() : 0); //correction for CRLF
  690|       |
  691|      2|        if(pOb)
  ------------------
  |  Branch (691:12): [True: 0, False: 2]
  ------------------
  692|      0|          {
  693|      0|            if(pOb1 && pOutFormat) //see if there is an object ready to be output
  ------------------
  |  Branch (693:16): [True: 0, False: 0]
  |  Branch (693:24): [True: 0, False: 0]
  ------------------
  694|      0|              {
  695|       |                //Output object
  696|      0|                if (!pOutFormat->WriteChemObject(this))
  ------------------
  |  Branch (696:21): [True: 0, False: 0]
  ------------------
  697|      0|                  {
  698|       |                    //faultly write, so finish
  699|      0|                    --Index;
  700|       |                    //ReadyToInput=false;
  701|      0|                    pOb1 = nullptr;
  702|       |                    // The newly-read object never gets stored on this
  703|       |                    // abort path; delete it so it does not leak.
  704|      0|                    delete pOb;
  705|      0|                    return 0;
  706|      0|                  }
  707|       |                //Stop after writing with single object output files
  708|      0|                if(pOutFormat->Flags() & WRITEONEONLY)
  ------------------
  |  |   36|      0|#define WRITEONEONLY    0x20
  ------------------
  |  Branch (708:20): [True: 0, False: 0]
  ------------------
  709|      0|                  {
  710|       |                    // if there are more molecules to output, send a warning
  711|      0|                    stringstream errorMsg;
  712|      0|                    errorMsg << "WARNING: You are attempting to convert a file"
  713|      0|                             << " with multiple molecule entries into a format"
  714|      0|                             << " which can only store one molecule. The current"
  715|      0|                             << " output will only contain the first molecule.\n\n";
  716|       |
  717|      0|                    errorMsg << "To convert this input into multiple separate"
  718|      0|                             << " output files, with one molecule per file, try:\n"
  719|      0|                             << "obabel [input] [output] -m\n\n";
  720|       |
  721|      0|                    errorMsg << "To pick one particular molecule"
  722|      0|                             << " (e.g., molecule 4), try:\n"
  723|      0|                             << "obabel -f 4 -l 4 [input] [output]" << endl;
  724|       |
  725|      0|                    obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning);
  726|       |
  727|      0|                    ReadyToInput = false;
  728|      0|                    pOb1 = nullptr;
  729|       |                    // Surplus newly-read object; never stored, must free.
  730|      0|                    delete pOb;
  731|      0|                    return Count; // >0
  732|      0|                  }
  733|      0|              }
  734|      0|            pOb1=pOb;
  735|      0|            wInpos = rInpos; //Save the position in the input file to be accessed when writing it
  736|      0|            wInlen = rInlen;
  737|      0|          }
  738|      2|      }
  739|      2|    return Count; // >0
  740|      2|  }
_ZN9OpenBabel12OBConversion10FindFormatEPKc:
  756|     22|  {
  757|     22|    return OBFormat::FindType(ID);
  758|     22|  }
_ZNK9OpenBabel12OBConversion8GetTitleEv:
  767|      3|  {
  768|      3|    return(InFilename.c_str());
  769|      3|  }
_ZN9OpenBabel12OBConversion11StreamState9pushInputERS0_:
  936|     11|  {
  937|     11|    assert(ownedStreams.size() == 0); //should be empty
  938|       |
  939|     11|    pStream = conv.pInput;
  940|     11|    std::copy(conv.ownedInStreams.begin(), conv.ownedInStreams.end(), std::back_inserter(ownedStreams));
  941|       |
  942|     11|    conv.pInput = nullptr;
  943|     11|    conv.ownedInStreams.clear();
  944|     11|  }
_ZN9OpenBabel12OBConversion11StreamState10pushOutputERS0_:
  967|     11|  {
  968|     11|    assert(ownedStreams.size() == 0); //should be empty
  969|       |
  970|     11|    pStream = conv.pOutput;
  971|     11|    std::copy(conv.ownedOutStreams.begin(), conv.ownedOutStreams.end(), std::back_inserter(ownedStreams));
  972|       |
  973|     11|    conv.pOutput = nullptr;
  974|     11|    conv.ownedOutStreams.clear();
  975|     11|  }
_ZN9OpenBabel12OBConversion13SetFirstInputEb:
 1188|     11|  {
 1189|     11|    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|     11|  }
_ZN9OpenBabel12OBConversion8IsOptionEPKcNS0_11Option_typeE:
 1627|     70|  {
 1628|       |    //Returns NULL if option not found or a pointer to the text if it is
 1629|     70|    map<string,string>::iterator pos;
 1630|     70|    pos = OptionsArray[opttyp].find(opt);
 1631|     70|    if(pos==OptionsArray[opttyp].end())
  ------------------
  |  Branch (1631:8): [True: 70, False: 0]
  ------------------
 1632|     70|      return nullptr;
 1633|      0|    return pos->second.c_str();
 1634|     70|  }
_ZN9OpenBabel12OBConversion16OptionParamArrayENS0_11Option_typeE:
 1667|    654|  {
 1668|    654|    static OPAMapType opa[3];
 1669|    654|    return opa[typ];
 1670|    654|  }
_ZN9OpenBabel12OBConversion19RegisterOptionParamENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8OBFormatEiNS0_11Option_typeE:
 1674|    218|  {
 1675|       |    //Gives error message if the number of parameters conflicts with an existing registration
 1676|    218|    map<string,int>::iterator pos;
 1677|    218|    pos =	OptionParamArray(typ).find(name);
 1678|    218|    if(pos!=OptionParamArray(typ).end())
  ------------------
  |  Branch (1678:8): [True: 84, False: 134]
  ------------------
 1679|     84|      {
 1680|     84|        if(pos->second!=numberParams)
  ------------------
  |  Branch (1680:12): [True: 0, False: 84]
  ------------------
 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|     84|      }
 1692|    218|    OptionParamArray(typ)[name] = numberParams;
 1693|    218|  }

_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|     11|  {
   37|     11|    std::istream *ifs = pConv->GetInStream();
   38|     11|    if (!ifs || !ifs->good())
  ------------------
  |  Branch (38:9): [True: 0, False: 11]
  |  Branch (38:17): [True: 0, False: 11]
  ------------------
   39|      0|      return false;
   40|       |
   41|     11|    OBMol* pmol = new OBMol;
   42|       |
   43|     11|    if(pConv->IsOption("C",OBConversion::GENOPTIONS))
  ------------------
  |  Branch (43:8): [True: 0, False: 11]
  ------------------
   44|      0|      return DeferMolOutput(pmol, pConv, pFormat);
   45|       |
   46|     11|    bool ret=true;
   47|     11|   if(pConv->IsOption("separate",OBConversion::GENOPTIONS))
  ------------------
  |  Branch (47:7): [True: 0, False: 11]
  ------------------
   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|     11|    ret=pFormat->ReadMolecule(pmol,pConv);
  102|       |
  103|     11|    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|     11|    if(ret && (pmol->NumAtoms() > 0
  ------------------
  |  Branch (107:8): [True: 2, False: 9]
  |  Branch (107:16): [True: 0, False: 2]
  ------------------
  108|      2|      || pmol->IsReaction()
  ------------------
  |  Branch (108:10): [True: 0, False: 2]
  ------------------
  109|      2|      || (pFormat->Flags()&ZEROATOMSOK && (*pmol->GetTitle() || pmol->HasData(1)))))
  ------------------
  |  |   34|      4|#define ZEROATOMSOK     0x08
  ------------------
  |  Branch (109:11): [True: 0, False: 2]
  |  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|     11|    else
  128|     11|      delete pmol;
  129|       |
  130|       |    // Normal operation - send molecule to be written
  131|     11|    ret = ret && (pConv->AddChemObject(ptmol)!=0); //success of both writing and reading
  ------------------
  |  Branch (131:11): [True: 2, False: 9]
  |  Branch (131:18): [True: 2, False: 0]
  ------------------
  132|     11|    return ret;
  133|     11|  }

_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|     24|{
   99|       |  // Make sure the plugins are loaded
  100|     24|  if (AllPluginsLoaded == 0) {
  ------------------
  |  Branch (100:7): [True: 0, False: 24]
  ------------------
  101|      0|    OBPlugin::LoadAllPlugins();
  102|      0|  }
  103|       |
  104|     24|  if(!ID || !*ID)
  ------------------
  |  Branch (104:6): [True: 0, False: 24]
  |  Branch (104:13): [True: 0, False: 24]
  ------------------
  105|      0|    return nullptr;
  106|     24|  PluginMapType::iterator itr = Map.find(ID);
  107|     24|  if(itr==Map.end())
  ------------------
  |  Branch (107:6): [True: 1, False: 23]
  ------------------
  108|      1|    return nullptr;
  109|     23|  else
  110|     23|    return itr->second;
  111|     24|}
_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|     11|      {
   49|     11|        startpos = s.find_first_not_of(delimstr,startpos);
   50|     11|        endpos = s.find_first_of(delimstr,startpos);
   51|       |
   52|     11|        if (endpos <= s.size() && startpos <= s.size())
  ------------------
  |  Branch (52:13): [True: 8, False: 3]
  |  Branch (52:35): [True: 8, False: 0]
  ------------------
   53|      8|          vcr.push_back(s.substr(startpos,endpos-startpos));
   54|      3|        else
   55|      3|          break;
   56|       |
   57|      8|        startpos = endpos+1;
   58|      8|      }
   59|       |
   60|      3|    return(true);
   61|      3|  }
_ZN9OpenBabel4TrimERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  136|      7|  {
  137|      7|    string::size_type pos = txt.find_last_not_of(" \t\n\r");
  138|      7|    if(pos!=string::npos)
  ------------------
  |  Branch (138:8): [True: 4, False: 3]
  ------------------
  139|      4|      txt.erase(pos+1);
  140|      3|    else
  141|      3|      txt.erase();
  142|       |
  143|      7|    pos = txt.find_first_not_of(" \t\n\r");
  144|      7|    if(pos!=string::npos)
  ------------------
  |  Branch (144:8): [True: 4, False: 3]
  ------------------
  145|      4|      txt.erase(0, pos);
  146|      3|    else
  147|      3|      txt.erase();
  148|      7|    return txt;
  149|      7|  }

_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|     11|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv:
  181|     11|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() {
  182|     11|  return ConsumeRandomLengthString(remaining_bytes_);
  183|     11|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|     11|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|     11|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|     11|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  4.35M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 4.35M, False: 3]
  |  Branch (164:40): [True: 4.35M, False: 0]
  ------------------
  165|  4.35M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  4.35M|    Advance(1);
  167|  4.35M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 19, False: 4.35M]
  |  Branch (167:25): [True: 19, False: 0]
  ------------------
  168|     19|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|     19|      Advance(1);
  170|     19|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 8, False: 11]
  ------------------
  171|      8|        break;
  172|     19|    }
  173|  4.35M|    result += next;
  174|  4.35M|  }
  175|       |
  176|     11|  result.shrink_to_fit();
  177|     11|  return result;
  178|     11|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  378|  4.35M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  379|  4.35M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  380|  4.35M|  static_assert(!std::numeric_limits<TU>::is_signed,
  381|  4.35M|                "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|  4.35M|  constexpr auto TS_max = static_cast<TU>(std::numeric_limits<TS>::max());
  389|  4.35M|  if (value <= TS_max) {
  ------------------
  |  Branch (389:7): [True: 2.55M, False: 1.79M]
  ------------------
  390|  2.55M|    return static_cast<TS>(value);
  391|  2.55M|  } else {
  392|  1.79M|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  393|  1.79M|    return TS_min + static_cast<TS>(value - TS_min);
  394|  1.79M|  }
  395|  4.35M|}
_ZN18FuzzedDataProvider7AdvanceEm:
  343|  4.35M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  344|  4.35M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (344:7): [True: 0, False: 4.35M]
  ------------------
  345|      0|    abort();
  346|       |
  347|  4.35M|  data_ptr_ += num_bytes;
  348|  4.35M|  remaining_bytes_ -= num_bytes;
  349|  4.35M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|     22|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|     22|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|     22|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|     22|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 22]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|     22|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|     22|  uint64_t result = 0;
  215|     22|  size_t offset = 0;
  216|       |
  217|     44|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 44, False: 0]
  |  Branch (217:43): [True: 22, False: 22]
  ------------------
  218|     22|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 22, 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|     22|    --remaining_bytes_;
  226|     22|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|     22|    offset += CHAR_BIT;
  228|     22|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|     22|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 22, False: 0]
  ------------------
  232|     22|    result = result % (range + 1);
  233|       |
  234|     22|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|     22|}

_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|     22|const char *randomFormat(FuzzedDataProvider &fdp) {
   21|     22|    static std::vector<std::string> formats = getAllFormats();
   22|     22|    return formats[fdp.ConsumeIntegralInRange<int>(0, formats.size() - 1)].c_str();
   23|     22|}
LLVMFuzzerTestOneInput:
   25|     11|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   26|     11|    using namespace OpenBabel;
   27|     11|    obErrorLog.StopLogging();
   28|       |
   29|     11|    FuzzedDataProvider fdp(Data, Size);
   30|     11|    OBConversion conv;
   31|     11|    conv.SetInFormat(randomFormat(fdp));
   32|     11|    conv.SetOutFormat(randomFormat(fdp));
   33|       |
   34|     11|    std::ostringstream outStream;
   35|     11|    std::istringstream inStream(fdp.ConsumeRandomLengthString());
   36|       |
   37|     11|    try {
   38|     11|        conv.Convert(&inStream, &outStream);
   39|     11|    } catch (...) {
   40|       |        // no error handling
   41|      0|    }
   42|       |
   43|     11|    return 0;
   44|     11|}