gistfile1.txt

;; Function void* memchr(void*, int, size_t) (*memchr)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = __builtin_memchr ((const void *) __s, __c, __n)
   >>>;


;; Function const void* memchr(const void*, int, size_t) (*memchr)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (const void *) __builtin_memchr (__s, __c, __n)
   >>>;


;; Function char* strchr(char*, int) (*strchr)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = __builtin_strchr ((const char *) __s, __c)
   >>>;


;; Function const char* strchr(const char*, int) (*strchr)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (const char *) __builtin_strchr (__s, __c)
   >>>;


;; Function char* strrchr(char*, int) (*strrchr)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = __builtin_strrchr ((const char *) __s, __c)
   >>>;


;; Function const char* strrchr(const char*, int) (*strrchr)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (const char *) __builtin_strrchr (__s, __c)
   >>>;


;; Function char* strpbrk(char*, const char*) (*strpbrk)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = __builtin_strpbrk ((const char *) __s, __accept)
   >>>;


;; Function const char* strpbrk(const char*, const char*) (*strpbrk)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (const char *) __builtin_strpbrk (__s, __accept)
   >>>;


;; Function char* strstr(char*, const char*) (*strstr)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = __builtin_strstr ((const char *) __haystack, __needle)
   >>>;


;; Function const char* strstr(const char*, const char*) (*strstr)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (const char *) __builtin_strstr (__haystack, __needle)
   >>>;


;; Function char* index(char*, int) (*index)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = __builtin_index ((const char *) __s, __c)
   >>>;


;; Function const char* index(const char*, int) (*index)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (const char *) __builtin_index (__s, __c)
   >>>;


;; Function char* rindex(char*, int) (*rindex)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = __builtin_rindex ((const char *) __s, __c)
   >>>;


;; Function const char* rindex(const char*, int) (*rindex)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (const char *) __builtin_rindex (__s, __c)
   >>>;


;; Function int atoi(const char*) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  <<cleanup_point return <retval> = (int) strtol (__nptr, 0B, 10)>>
   >>>;


;; Function long int atol(const char*) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  <<cleanup_point return <retval> = strtol (__nptr, 0B, 10)>>
   >>>;


;; Function long long int atoll(const char*) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  <<cleanup_point return <retval> = strtoll (__nptr, 0B, 10)>>
   >>>;


;; Function unsigned int __bswap_32(unsigned int) (null)
;; enabled by -tree-original


return <retval> = __builtin_bswap32 (__bsx);


;; Function __uint64_t __bswap_64(__uint64_t) (null)
;; enabled by -tree-original


return <retval> = __builtin_bswap64 (__bsx);


;; Function __uint16_t __uint16_identity(__uint16_t) (null)
;; enabled by -tree-original


return <retval> = __x;


;; Function __uint32_t __uint32_identity(__uint32_t) (null)
;; enabled by -tree-original


return <retval> = __x;


;; Function __uint64_t __uint64_identity(__uint64_t) (null)
;; enabled by -tree-original


return <retval> = __x;


;; Function unsigned int gnu_dev_major(__dev_t) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  {
    unsigned int __major;

        unsigned int __major;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__major = (unsigned int) (__dev >> 8) & 4095) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__major = (unsigned int) (__dev >> 32) & 4294963200 | __major) >>>>>;
    return <retval> = __major;
  }
   >>>;


;; Function unsigned int gnu_dev_minor(__dev_t) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  {
    unsigned int __minor;

        unsigned int __minor;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__minor = (unsigned int) __dev & 255) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__minor = (unsigned int) (__dev >> 12) & 4294967040 | __minor) >>>>>;
    return <retval> = __minor;
  }
   >>>;


;; Function __dev_t gnu_dev_makedev(unsigned int, unsigned int) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  {
    __dev_t __dev;

        __dev_t __dev;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__dev = (__dev_t) __major << 8 & 1048320) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__dev = (__dev_t) __major << 32 & 18446726481523507200 | __dev) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__dev = (__dev_t) __minor & 255 | __dev) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__dev = (__dev_t) __minor << 12 & 17592184995840 | __dev) >>>>>;
    return <retval> = __dev;
  }
   >>>;


;; Function void* bsearch(const void*, const void*, size_t, size_t, __compar_fn_t) (null)
;; enabled by -tree-original


{
  size_t __l;
  size_t __u;
  size_t __idx;
  const void * __p;
  int __comparison;

    size_t __l;
    size_t __u;
    size_t __idx;
    const void * __p;
    int __comparison;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__l = 0) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__u = __nmemb) >>>>>;
  while (1)
    {
      if (__l >= __u) goto <D.2963>;
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__idx = (__l + __u) / 2) >>>>>;
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__p = __base + (sizetype) (__idx * __size)) >>>>>;
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__comparison = __compar (__key, __p)) >>>>>;
      if (__comparison < 0)
        {
          <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__u = __idx) >>>>>;
        }
      else
        {
          if (__comparison > 0)
            {
              <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__l = __idx + 1) >>>>>;
            }
          else
            {
              return <retval> = (void *) __p;
            }
        }
    }
  <D.2963>:;
  return <retval> = 0B;
}


;; Function double atof(const char*) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  <<cleanup_point return <retval> = strtod (__nptr, 0B)>>
   >>>;


;; Function long int std::abs(long int) (null)
;; enabled by -tree-original


return <retval> = ABS_EXPR <__i>;


;; Function long long int std::abs(long long int) (null)
;; enabled by -tree-original


return <retval> = ABS_EXPR <__x>;


;; Function constexpr double std::abs(double) (null)
;; enabled by -tree-original


return <retval> = ABS_EXPR <__x>;


;; Function constexpr float std::abs(float) (null)
;; enabled by -tree-original


return <retval> = ABS_EXPR <__x>;


;; Function constexpr long double std::abs(long double) (null)
;; enabled by -tree-original


return <retval> = ABS_EXPR <__x>;


;; Function ldiv_t std::div(long int, long int) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = TARGET_EXPR <D.3143, ldiv (__i, __j)>>>;


;; Function lldiv_t __gnu_cxx::div(long long int, long long int) (null)
;; enabled by -tree-original


{
  struct lldiv_t __q;

    struct lldiv_t __q;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__q.quot = __n / __d) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (__q.rem = __n % __d) >>>>>;
  <<cleanup_point return <retval> = TARGET_EXPR <D.3218, __q>>>;
}


;; Function int vprintf(const char*, __va_list_tag*) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = vfprintf (stdout, __fmt, __arg)>>;


;; Function int getchar() (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = _IO_getc (stdin)>>;


;; Function int fgetc_unlocked(FILE*) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = __builtin_expect (__fp->_IO_read_ptr >= __fp->_IO_read_end, 0) != 0 ? __uflow (__fp) : (int) *(unsigned char *) __fp->_IO_read_ptr++ >>;


;; Function int getc_unlocked(FILE*) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = __builtin_expect (__fp->_IO_read_ptr >= __fp->_IO_read_end, 0) != 0 ? __uflow (__fp) : (int) *(unsigned char *) __fp->_IO_read_ptr++ >>;


;; Function int getchar_unlocked() (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = __builtin_expect (stdin->_IO_read_ptr >= stdin->_IO_read_end, 0) != 0 ? __uflow (stdin) : (int) *(unsigned char *) stdin->_IO_read_ptr++ >>;


;; Function int putchar(int) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = _IO_putc (__c, stdout)>>;


;; Function int fputc_unlocked(int, FILE*) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = __builtin_expect (__stream->_IO_write_ptr >= __stream->_IO_write_end, 0) != 0 ? __overflow (__stream, (int) (unsigned char) __c) : (int) (unsigned char) (*__stream->_IO_write_ptr++  = (char) __c)>>;


;; Function int putc_unlocked(int, FILE*) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = __builtin_expect (__stream->_IO_write_ptr >= __stream->_IO_write_end, 0) != 0 ? __overflow (__stream, (int) (unsigned char) __c) : (int) (unsigned char) (*__stream->_IO_write_ptr++  = (char) __c)>>;


;; Function int putchar_unlocked(int) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = __builtin_expect (stdout->_IO_write_ptr >= stdout->_IO_write_end, 0) != 0 ? __overflow (stdout, (int) (unsigned char) __c) : (int) (unsigned char) (*stdout->_IO_write_ptr++  = (char) __c)>>;


;; Function __ssize_t getline(char**, size_t*, FILE*) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = __getdelim (__lineptr, __n, 10, __stream)>>;


;; Function int feof_unlocked(FILE*) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (__stream->_flags & 16) != 0
   >>>;


;; Function int ferror_unlocked(FILE*) (null)
;; enabled by -tree-original


<<< Unknown tree: eh_spec_block
  return <retval> = (__stream->_flags & 32) != 0
   >>>;


;; Function cTest* cTestList::GetHead() (null)
;; enabled by -tree-original


return <retval> = ((struct cTestList *) this)->m_pHead;


;; Function cTest* cTestList::GetTail() (null)
;; enabled by -tree-original


return <retval> = ((struct cTestList *) this)->m_pTail;


;; Function kbSize cTestList::GetSize() const (null)
;; enabled by -tree-original


return <retval> = (kbSize) ((const struct cTestList *) this)->m_nSize;


;; Function cTestList* cTest::GetTests() (null)
;; enabled by -tree-original


return <retval> = &((struct cTest *) this)->m_dTests;


;; Function cTest* cTest::GetNext() (null)
;; enabled by -tree-original


return <retval> = ((struct cTest *) this)->m_pNext;


;; Function cTest* cTest::GetPrev() (null)
;; enabled by -tree-original


return <retval> = ((struct cTest *) this)->m_pPrev;


;; Function const char* cTest::GetName() const (null)
;; enabled by -tree-original


return <retval> = (const char *) ((const struct cTest *) this)->m_pchName;


;; Function constexpr cTestRegister::cTestRegister(const char*, const char*) (null)
;; enabled by -tree-original


<<cleanup_point <<< Unknown tree: expr_stmt
  *(struct 
  {
    const char * m_pchRoot;
    const char * m_pchName;
  } &) this = {CLOBBER} >>>>>;
{
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTestRegister *) this)->m_pchRoot = pchRoot) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTestRegister *) this)->m_pchName = pchName) >>>>>;
}


;; Function cTestList::cTestList() (null)
;; enabled by -tree-original


<<cleanup_point <<< Unknown tree: expr_stmt
  *(struct 
  {
    struct cTest * m_pHead;
    struct cTest * m_pTail;
    kbSize m_nSize;
  } &) this = {CLOBBER} >>>>>;
{
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTestList *) this)->m_pHead = 0B) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTestList *) this)->m_pTail = 0B) >>>>>;
}


;; Function void cTestList::AddTest(cTest*) (null)
;; enabled by -tree-original


if (((struct cTestList *) this)->m_pTail != 0B)
  {
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTestList *) this)->m_pTail->m_pNext = pTest) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTest->m_pPrev = ((struct cTestList *) this)->m_pTail) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTest->m_pNext = 0B) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTestList *) this)->m_pTail = pTest) >>>>>;
  }
else
  {
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTestList *) this)->m_pHead = pTest) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTestList *) this)->m_pTail = pTest) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTest->m_pNext = 0B) >>>>>;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTest->m_pPrev = 0B) >>>>>;
  }
<<cleanup_point <<< Unknown tree: expr_stmt
  (void) ((struct cTestList *) this)->m_nSize++  >>>>>;


;; Function cTest::cTest(const char*, const char*, void (*)(cTest*)) (null)
;; enabled by -tree-original


<<cleanup_point <<< Unknown tree: expr_stmt
  *(struct 
  {
    const char * m_pchName;
    void (*<Taf7>) (struct cTest *) m_pfnTest;
    struct cTest * m_pNext;
    struct cTest * m_pPrev;
    struct cTestList m_dTests;
    int m_nIndex;
    kbSize m_nAsserts;
  } &) this = {CLOBBER} >>>>>;
{
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTest *) this)->m_pchName = pchName) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTest *) this)->m_pfnTest = pfnTest) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTest *) this)->m_pNext = 0B) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTest *) this)->m_pPrev = 0B) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  cTestList::cTestList (&((struct cTest *) this)->m_dTests) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTest *) this)->m_nIndex = 0) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTest *) this)->m_nAsserts = 0) >>>>>;
  {
    struct cTestList * pList;

        struct cTestList * pList;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pList = scTest::FindTests (pchRoot)) >>>>>;
    if (pList != 0B)
      {
        <<cleanup_point <<< Unknown tree: expr_stmt
  cTestList::AddTest (NON_LVALUE_EXPR <pList>, (struct cTest *) this) >>>>>;
      }
  }
}


;; Function kbBool cTest::Run(int) (null)
;; enabled by -tree-original


{
  const char * pchType = ((struct cTest *) this)->m_nIndex != 0 ? (const char *) "Subtest" : (const char *) "Test";
  struct cTestList * pTests;
  const kbSize nSubTests;
  kbSize nFailedSubTests = 0;

  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (((struct cTest *) this)->m_nIndex = nIndex) >>>>>;
    const char * pchType = ((struct cTest *) this)->m_nIndex != 0 ? (const char *) "Subtest" : (const char *) "Test";
    struct cTestList * pTests;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTests = cTest::GetTests ((struct cTest *) this)) >>>>>;
    const kbSize nSubTests;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (nSubTests = cTestList::GetSize (NON_LVALUE_EXPR <pTests>)) >>>>>;
  if (nSubTests != 0)
    {
      <<cleanup_point <<< Unknown tree: expr_stmt
  cTest::Indent ((struct cTest *) this) >>>>>;
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "%s \'%s\' running (%zu subtest(s))\n", pchType, ((struct cTest *) this)->m_pchName, (kbSize) nSubTests) >>>>>;
    }
  else
    {
      <<cleanup_point <<< Unknown tree: expr_stmt
  cTest::Indent ((struct cTest *) this) >>>>>;
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "%s \'%s\' running\n", pchType, ((struct cTest *) this)->m_pchName) >>>>>;
    }
  <<cleanup_point   kbSize nFailedSubTests = 0;>>;
  {
    struct cTest * pTest;

        struct cTest * pTest;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTest = cTestList::GetHead (NON_LVALUE_EXPR <pTests>)) >>>>>;
    while (1)
      {
        if (pTest == 0B) goto <D.3970>;
        if (<<cleanup_point !cTest::Run (NON_LVALUE_EXPR <pTest>, nIndex + 1)>>)
          {
            <<cleanup_point <<< Unknown tree: expr_stmt
  (void) nFailedSubTests++  >>>>>;
          }
        <<cleanup_point (void) (pTest = cTest::GetNext (NON_LVALUE_EXPR <pTest>))>>;
      }
    <D.3970>:;
  }
  if (((struct cTest *) this)->m_pfnTest != 0B)
    {
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) ((struct cTest *) this)->m_nIndex++  >>>>>;
      <<cleanup_point <<< Unknown tree: expr_stmt
  ((struct cTest *) this)->m_pfnTest ((struct cTest *) this) >>>>>;
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) ((struct cTest *) this)->m_nIndex--  >>>>>;
    }
  if ((((struct cTest *) this)->m_nAsserts | nFailedSubTests) != 0)
    {
      <<cleanup_point <<< Unknown tree: expr_stmt
  cTest::Indent ((struct cTest *) this) >>>>>;
      if (nSubTests != 0 && nFailedSubTests != 0)
        {
          if (((struct cTest *) this)->m_nAsserts != 0)
            {
              <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "%s \'%s\' failed (%zu assertion(s)) (%zu/%zu subtest(s) failed)\n", pchType, ((struct cTest *) this)->m_pchName, ((struct cTest *) this)->m_nAsserts, nFailedSubTests, (kbSize) nSubTests) >>>>>;
            }
          else
            {
              <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "%s \'%s\' failed (%zu/%zu subtest(s) failed)\n", pchType, ((struct cTest *) this)->m_pchName, nFailedSubTests, (kbSize) nSubTests) >>>>>;
            }
        }
      else
        {
          <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "%s \'%s\' failed (%zu assertion(s))\n", pchType, ((struct cTest *) this)->m_pchName, ((struct cTest *) this)->m_nAsserts) >>>>>;
        }
      return <retval> = 0;
    }
  <<cleanup_point <<< Unknown tree: expr_stmt
  cTest::Indent ((struct cTest *) this) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "%s \'%s\' passed\n", pchType, ((struct cTest *) this)->m_pchName) >>>>>;
  return <retval> = 1;
}


;; Function void cTest::Assert(const char*, const char*, int) (null)
;; enabled by -tree-original


<<cleanup_point <<< Unknown tree: expr_stmt
  cTest::Indent ((struct cTest *) this) >>>>>;
<<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "Assertion failed: %s (%s:%d)\n", pchMessage, pchFile, nLine) >>>>>;
<<cleanup_point <<< Unknown tree: expr_stmt
  (void) ((struct cTest *) this)->m_nAsserts++  >>>>>;


;; Function void cTest::Indent() (null)
;; enabled by -tree-original


{
  {
    int nIndex = 0;

    <<cleanup_point     int nIndex = 0;>>;
    while (1)
      {
        if (((struct cTest *) this)->m_nIndex <= nIndex) goto <D.3982>;
        <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "\xe2\x94\x82  ") >>>>>;
        <<cleanup_point (void) nIndex++ >>;
      }
    <D.3982>:;
  }
}


;; Function cTest cTestRegister::operator+(void (*)(cTest*)) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = TARGET_EXPR <D.3989, <<< Unknown tree: aggr_init_expr
  7
  __comp_ctor 
  D.3989
  (struct cTest *) <<< Unknown tree: void_cst >>>
  ((struct cTestRegister *) this)->m_pchRoot
  ((struct cTestRegister *) this)->m_pchName
  pchTest >>>>>>;


;; Function static cTestList* scTest::GetTests() (_ZN6scTest8GetTestsEv)
;; enabled by -tree-original


{
  static struct cTestList dList;

    static struct cTestList dList;
  if (<<cleanup_point __atomic_load_1 (&_ZGVZN6scTest8GetTestsEvE5dList, 2) == 0>>)
    {
      if (<<cleanup_point __cxa_guard_acquire (&_ZGVZN6scTest8GetTestsEvE5dList) != 0>>)
        {
          <<cleanup_point <<< Unknown tree: expr_stmt
  TARGET_EXPR <D.4007, 0>;, cTestList::cTestList (&dList);;, D.4007 = 1;;, __cxa_guard_release (&_ZGVZN6scTest8GetTestsEvE5dList); >>>>>;
        }
    }
  return <retval> = &dList;
}


;; Function static kbBool scTest::Run() (null)
;; enabled by -tree-original


{
  struct cTestList * pTests;
  const kbSize nTests;
  kbSize nFailedTests = 0;

    struct cTestList * pTests;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTests = scTest::GetTests ()) >>>>>;
    const kbSize nTests;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (nTests = cTestList::GetSize (NON_LVALUE_EXPR <pTests>)) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "Running %zu test(s) ...\n", (kbSize) nTests) >>>>>;
  <<cleanup_point   kbSize nFailedTests = 0;>>;
  {
    struct cTest * pTest;

        struct cTest * pTest;
    <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTest = cTestList::GetHead (NON_LVALUE_EXPR <pTests>)) >>>>>;
    while (1)
      {
        if (pTest == 0B) goto <D.4015>;
        if (<<cleanup_point !cTest::Run (NON_LVALUE_EXPR <pTest>, 0)>>)
          {
            <<cleanup_point <<< Unknown tree: expr_stmt
  (void) nFailedTests++  >>>>>;
          }
        <<cleanup_point (void) (pTest = cTest::GetNext (NON_LVALUE_EXPR <pTest>))>>;
      }
    <D.4015>:;
  }
  if (nFailedTests != 0)
    {
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "%zu of %zu test(s) failed!\n", nFailedTests, (kbSize) nTests) >>>>>;
      return <retval> = 0;
    }
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) printf ((const char *) "All tests passed!\n") >>>>>;
  return <retval> = 1;
}


;; Function scTest::FindTests(const char*)::<lambda(cTestList*, const char*)> (null)
;; enabled by -tree-original


{
  {
    {
      struct cTest * pTest;

            struct cTest * pTest;
      <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTest = cTestList::GetHead (NON_LVALUE_EXPR <pCurrent>)) >>>>>;
      while (1)
        {
          if (pTest == 0B) goto <D.4036>;
          if (<<cleanup_point strcmp (pchName, cTest::GetName (NON_LVALUE_EXPR <pTest>)) == 0>>)
            {
              <<cleanup_point return <retval> = cTest::GetTests (NON_LVALUE_EXPR <pTest>)>>;
            }
          <<cleanup_point (void) (pTest = cTest::GetNext (NON_LVALUE_EXPR <pTest>))>>;
        }
      <D.4036>:;
    }
    return <retval> = 0B;
  }
}


;; Function static cTestList* scTest::FindTests(const char*)::<lambda(cTestList*, const char*)>::_FUN(cTestList*, const char*) (null)
;; enabled by -tree-original


<<cleanup_point return <retval> = scTest::FindTests(const char*)::<lambda(cTestList*, const char*)>::operator() (0B, D.4038, D.4039)>>;


;; Function scTest::FindTests(const char*)::<lambda(cTestList*, const char*)>::operator cTestList* (*)(cTestList*, const char*)() const (null)
;; enabled by -tree-original


return <retval> = _FUN;


;; Function static cTestList* scTest::FindTests(const char*) (null)
;; enabled by -tree-original


{
  struct cTestList * pTests;

    struct cTestList * pTests;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pTests = scTest::GetTests ()) >>>>>;
  if (pTests == 0B)
    {
      <<cleanup_point <<< Unknown tree: expr_stmt
  abort () >>>>>;
    }
  {
    if (pchRoot != 0B)
      {
        {
          char achBuffer[4096];
          struct cTestList * pList = pTests;
          char * save = 0B;
          char * pchToken;
          struct __lambda0 fnSearch;
          typedef struct __lambda0 __lambda0;

                    char achBuffer[4096];
          <<cleanup_point <<< Unknown tree: expr_stmt
  (void) snprintf ((char *) &achBuffer, 4096, (const char *) "%s", pchRoot) >>>>>;
                    struct cTestList * pList = pTests;
          <<cleanup_point           char * save = 0B;>>;
                    char * pchToken;
          <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pchToken = strtok_r ((char *) &achBuffer, (const char *) ".", &save)) >>>>>;
                    struct __lambda0 fnSearch;
          <<< Unknown tree: expr_stmt
   >>>;
          if (pchToken == 0B)
            {
              <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pList = scTest::FindTests(const char*)::<lambda(cTestList*, const char*)>::operator() (&fnSearch, pList, (const char *) &achBuffer)) >>>>>;
            }
          else
            {
              while (1)
                {
                  if (pchToken == 0B) goto <D.4080>;
                  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pList = scTest::FindTests(const char*)::<lambda(cTestList*, const char*)>::operator() (&fnSearch, pList, (const char *) pchToken)) >>>>>;
                  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) (pchToken = strtok_r (0B, (const char *) ".", &save)) >>>>>;
                }
              <D.4080>:;
            }
          return <retval> = pList != pTests ? pList : 0B;
        }
      }
  }
  return <retval> = pTests;
}